# Generated from CPP14Parser.g4 by ANTLR 4.11.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,146,2110,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,
        2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,
        7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,1,0,3,0,384,
        8,0,1,0,1,0,1,1,4,1,389,8,1,11,1,12,1,390,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,3,1,400,8,1,1,2,1,2,3,2,404,8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,
        3,3,3,413,8,3,1,3,3,3,416,8,3,1,4,1,4,3,4,420,8,4,1,4,1,4,1,5,1,
        5,1,5,1,5,3,5,428,8,5,1,5,1,5,1,5,1,5,1,5,3,5,435,8,5,1,5,3,5,438,
        8,5,1,5,5,5,441,8,5,10,5,12,5,444,9,5,1,6,1,6,3,6,448,8,6,1,6,1,
        6,1,7,1,7,3,7,454,8,7,1,7,1,7,1,8,1,8,1,8,1,8,3,8,462,8,8,3,8,464,
        8,8,1,9,1,9,1,10,1,10,1,10,5,10,471,8,10,10,10,12,10,474,9,10,1,
        10,3,10,477,8,10,1,11,1,11,3,11,481,8,11,1,12,3,12,484,8,12,1,12,
        1,12,3,12,488,8,12,1,13,3,13,491,8,13,1,13,1,13,1,13,1,14,1,14,3,
        14,498,8,14,1,14,1,14,3,14,502,8,14,1,14,3,14,505,8,14,1,14,3,14,
        508,8,14,1,14,3,14,511,8,14,1,15,1,15,1,15,1,15,3,15,517,8,15,1,
        15,1,15,3,15,521,8,15,1,15,1,15,3,15,525,8,15,1,15,1,15,1,15,1,15,
        1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,539,8,15,1,15,1,15,
        3,15,543,8,15,1,15,1,15,1,15,1,15,3,15,549,8,15,1,15,1,15,1,15,1,
        15,1,15,3,15,556,8,15,1,15,1,15,1,15,1,15,3,15,562,8,15,1,15,1,15,
        3,15,566,8,15,1,15,1,15,5,15,570,8,15,10,15,12,15,573,9,15,1,16,
        1,16,1,17,1,17,1,18,3,18,580,8,18,1,18,1,18,1,18,3,18,585,8,18,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,598,8,
        18,1,19,1,19,1,19,1,19,1,19,3,19,605,8,19,1,19,1,19,1,19,1,19,1,
        19,1,19,1,19,1,19,1,19,1,19,3,19,617,8,19,1,19,1,19,1,19,1,19,1,
        19,1,19,1,19,1,19,3,19,627,8,19,1,20,1,20,1,21,3,21,632,8,21,1,21,
        1,21,3,21,636,8,21,1,21,1,21,1,21,1,21,1,21,3,21,643,8,21,1,21,3,
        21,646,8,21,1,22,1,22,1,22,1,22,1,23,1,23,3,23,654,8,23,1,24,1,24,
        3,24,658,8,24,1,24,3,24,661,8,24,1,25,1,25,1,25,1,25,1,25,3,25,668,
        8,25,1,25,1,25,1,25,1,25,1,25,3,25,675,8,25,5,25,677,8,25,10,25,
        12,25,680,9,25,1,26,1,26,3,26,684,8,26,1,26,1,26,3,26,688,8,26,1,
        27,3,27,691,8,27,1,27,1,27,1,27,3,27,696,8,27,1,27,1,27,1,28,1,28,
        1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,3,29,711,8,29,1,30,
        1,30,1,30,5,30,716,8,30,10,30,12,30,719,9,30,1,31,1,31,1,31,5,31,
        724,8,31,10,31,12,31,727,9,31,1,32,1,32,1,32,5,32,732,8,32,10,32,
        12,32,735,9,32,1,33,1,33,1,33,1,33,5,33,741,8,33,10,33,12,33,744,
        9,33,1,34,1,34,1,34,1,34,3,34,750,8,34,1,35,1,35,1,35,5,35,755,8,
        35,10,35,12,35,758,9,35,1,36,1,36,1,36,5,36,763,8,36,10,36,12,36,
        766,9,36,1,37,1,37,1,37,5,37,771,8,37,10,37,12,37,774,9,37,1,38,
        1,38,1,38,5,38,779,8,38,10,38,12,38,782,9,38,1,39,1,39,1,39,5,39,
        787,8,39,10,39,12,39,790,9,39,1,40,1,40,1,40,5,40,795,8,40,10,40,
        12,40,798,9,40,1,41,1,41,1,41,5,41,803,8,41,10,41,12,41,806,9,41,
        1,42,1,42,1,42,1,42,1,42,1,42,3,42,814,8,42,1,43,1,43,1,43,1,43,
        1,43,1,43,3,43,822,8,43,1,44,1,44,1,45,1,45,1,45,5,45,829,8,45,10,
        45,12,45,832,9,45,1,46,1,46,1,47,1,47,1,47,3,47,839,8,47,1,47,1,
        47,1,47,1,47,1,47,1,47,3,47,847,8,47,3,47,849,8,47,1,48,3,48,852,
        8,48,1,48,1,48,1,48,1,48,3,48,858,8,48,1,48,1,48,1,48,1,49,3,49,
        864,8,49,1,49,1,49,1,50,1,50,3,50,870,8,50,1,50,1,50,1,51,4,51,875,
        8,51,11,51,12,51,876,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,886,
        8,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,894,8,52,1,53,1,53,3,53,
        898,8,53,1,53,1,53,1,53,1,53,1,53,3,53,905,8,53,3,53,907,8,53,1,
        54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,
        54,1,54,1,54,1,54,1,54,3,54,927,8,54,1,54,1,54,3,54,931,8,54,1,54,
        1,54,1,54,1,54,3,54,937,8,54,1,54,1,54,1,54,3,54,942,8,54,1,55,1,
        55,3,55,946,8,55,1,56,3,56,949,8,56,1,56,1,56,1,56,1,57,1,57,3,57,
        956,8,57,1,58,1,58,1,58,1,58,1,58,3,58,963,8,58,1,58,1,58,3,58,967,
        8,58,1,58,1,58,1,59,1,59,1,60,4,60,974,8,60,11,60,12,60,975,1,61,
        1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,987,8,61,1,62,1,62,
        1,62,1,62,1,62,1,62,1,62,1,62,3,62,997,8,62,1,63,1,63,1,63,3,63,
        1002,8,63,1,63,1,63,1,63,1,63,1,64,3,64,1009,8,64,1,64,3,64,1012,
        8,64,1,64,1,64,1,64,3,64,1017,8,64,1,64,1,64,1,64,3,64,1022,8,64,
        1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,67,1,67,1,67,
        1,68,1,68,1,68,1,68,1,68,1,68,3,68,1043,8,68,1,69,4,69,1046,8,69,
        11,69,12,69,1047,1,69,3,69,1051,8,69,1,70,1,70,1,71,1,71,1,72,1,
        72,1,73,1,73,1,73,3,73,1062,8,73,1,74,1,74,1,74,1,74,3,74,1068,8,
        74,1,75,4,75,1071,8,75,11,75,12,75,1072,1,75,3,75,1076,8,75,1,76,
        4,76,1079,8,76,11,76,12,76,1080,1,76,3,76,1084,8,76,1,77,1,77,1,
        78,1,78,1,79,3,79,1091,8,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,3,
        79,1100,8,79,1,79,4,79,1103,8,79,11,79,12,79,1104,1,79,3,79,1108,
        8,79,1,79,1,79,3,79,1112,8,79,1,79,1,79,3,79,1116,8,79,1,79,1,79,
        3,79,1120,8,79,1,79,1,79,1,79,3,79,1125,8,79,1,79,5,79,1128,8,79,
        10,79,12,79,1131,9,79,1,79,1,79,1,79,3,79,1136,8,79,1,79,1,79,1,
        79,1,79,3,79,1142,8,79,1,80,1,80,1,80,1,80,3,80,1148,8,80,1,81,1,
        81,1,81,1,81,3,81,1154,8,81,1,81,1,81,1,82,1,82,3,82,1160,8,82,1,
        82,3,82,1163,8,82,1,82,1,82,1,82,1,82,3,82,1169,8,82,1,82,1,82,3,
        82,1173,8,82,1,82,1,82,3,82,1177,8,82,1,82,3,82,1180,8,82,1,83,1,
        83,1,84,1,84,1,84,1,84,3,84,1188,8,84,3,84,1190,8,84,1,84,1,84,1,
        85,1,85,3,85,1196,8,85,1,85,3,85,1199,8,85,1,85,3,85,1202,8,85,1,
        85,3,85,1205,8,85,1,86,1,86,3,86,1209,8,86,1,86,1,86,3,86,1213,8,
        86,1,86,1,86,1,87,1,87,3,87,1219,8,87,1,88,1,88,1,88,1,89,1,89,1,
        89,5,89,1227,8,89,10,89,12,89,1230,9,89,1,90,1,90,1,90,3,90,1235,
        8,90,1,91,1,91,1,92,1,92,3,92,1241,8,92,1,93,1,93,1,94,3,94,1246,
        8,94,1,94,1,94,1,94,3,94,1251,8,94,1,94,1,94,3,94,1255,8,94,1,94,
        1,94,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,97,3,97,1268,8,97,
        1,97,1,97,1,98,1,98,3,98,1274,8,98,1,98,1,98,3,98,1278,8,98,1,98,
        1,98,1,98,1,99,3,99,1284,8,99,1,99,1,99,1,99,3,99,1289,8,99,1,99,
        1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,
        1,101,3,101,1304,8,101,1,101,1,101,3,101,1308,8,101,1,102,4,102,
        1311,8,102,11,102,12,102,1312,1,103,1,103,1,103,3,103,1318,8,103,
        1,103,1,103,1,103,3,103,1323,8,103,1,104,1,104,1,104,1,104,3,104,
        1329,8,104,1,104,3,104,1332,8,104,1,104,1,104,1,105,1,105,1,105,
        5,105,1339,8,105,10,105,12,105,1342,9,105,1,105,3,105,1345,8,105,
        1,106,1,106,1,106,3,106,1350,8,106,1,106,1,106,3,106,1354,8,106,
        1,107,1,107,1,108,1,108,3,108,1360,8,108,1,108,1,108,1,109,4,109,
        1365,8,109,11,109,12,109,1366,1,110,1,110,1,110,1,110,1,110,1,110,
        1,110,1,110,1,110,1,110,1,110,1,110,1,110,4,110,1382,8,110,11,110,
        12,110,1383,3,110,1386,8,110,1,111,1,111,1,111,5,111,1391,8,111,
        10,111,12,111,1394,9,111,1,112,1,112,3,112,1398,8,112,1,113,1,113,
        1,113,1,113,1,113,3,113,1405,8,113,1,114,1,114,3,114,1409,8,114,
        5,114,1411,8,114,10,114,12,114,1414,9,114,1,114,1,114,1,115,1,115,
        1,115,3,115,1421,8,115,1,115,1,115,1,115,1,115,3,115,1427,8,115,
        1,115,1,115,1,115,1,115,3,115,1433,8,115,1,115,1,115,3,115,1437,
        8,115,3,115,1439,8,115,5,115,1441,8,115,10,115,12,115,1444,9,115,
        1,116,1,116,3,116,1448,8,116,1,116,1,116,3,116,1452,8,116,1,116,
        3,116,1455,8,116,1,116,3,116,1458,8,116,1,116,3,116,1461,8,116,1,
        117,1,117,1,117,3,117,1466,8,117,1,118,1,118,3,118,1470,8,118,1,
        118,3,118,1473,8,118,1,118,1,118,3,118,1477,8,118,1,118,3,118,1480,
        8,118,3,118,1482,8,118,1,119,4,119,1485,8,119,11,119,12,119,1486,
        1,120,1,120,1,121,1,121,1,122,3,122,1494,8,122,1,122,1,122,1,123,
        1,123,3,123,1500,8,123,1,124,1,124,3,124,1504,8,124,1,124,1,124,
        1,124,1,124,3,124,1510,8,124,1,125,1,125,4,125,1514,8,125,11,125,
        12,125,1515,1,125,3,125,1519,8,125,3,125,1521,8,125,1,126,1,126,
        1,126,1,126,3,126,1527,8,126,1,126,1,126,3,126,1531,8,126,1,126,
        1,126,1,126,1,126,3,126,1537,8,126,1,126,1,126,1,126,1,126,1,126,
        3,126,1544,8,126,1,126,1,126,3,126,1548,8,126,3,126,1550,8,126,5,
        126,1552,8,126,10,126,12,126,1555,9,126,1,127,5,127,1558,8,127,10,
        127,12,127,1561,9,127,1,127,1,127,1,128,1,128,1,128,1,128,1,128,
        1,128,1,128,3,128,1572,8,128,1,128,1,128,3,128,1576,8,128,3,128,
        1578,8,128,5,128,1580,8,128,10,128,12,128,1583,9,128,1,129,1,129,
        3,129,1587,8,129,1,129,3,129,1590,8,129,1,130,1,130,1,130,5,130,
        1595,8,130,10,130,12,130,1598,9,130,1,131,3,131,1601,8,131,1,131,
        1,131,1,131,3,131,1606,8,131,3,131,1608,8,131,1,131,1,131,3,131,
        1612,8,131,1,132,3,132,1615,8,132,1,132,3,132,1618,8,132,1,132,1,
        132,3,132,1622,8,132,1,132,1,132,1,133,3,133,1627,8,133,1,133,1,
        133,1,133,1,133,1,133,3,133,1634,8,133,1,134,1,134,1,134,1,134,1,
        134,3,134,1641,8,134,1,135,1,135,1,135,3,135,1646,8,135,1,136,1,
        136,3,136,1650,8,136,1,137,1,137,3,137,1654,8,137,1,137,1,137,1,
        137,3,137,1659,8,137,5,137,1661,8,137,10,137,12,137,1664,9,137,1,
        138,1,138,1,138,3,138,1669,8,138,3,138,1671,8,138,1,138,1,138,1,
        139,1,139,3,139,1677,8,139,1,140,1,140,1,140,3,140,1682,8,140,1,
        140,1,140,1,141,1,141,3,141,1688,8,141,1,141,1,141,3,141,1692,8,
        141,3,141,1694,8,141,1,141,3,141,1697,8,141,1,141,1,141,3,141,1701,
        8,141,1,141,1,141,3,141,1705,8,141,3,141,1707,8,141,3,141,1709,8,
        141,1,142,3,142,1712,8,142,1,142,1,142,1,143,1,143,1,144,1,144,1,
        145,1,145,1,145,1,145,4,145,1724,8,145,11,145,12,145,1725,1,146,
        3,146,1729,8,146,1,146,3,146,1732,8,146,1,146,3,146,1735,8,146,1,
        146,1,146,1,146,1,146,1,146,1,146,1,146,3,146,1744,8,146,1,147,1,
        147,1,147,5,147,1749,8,147,10,147,12,147,1752,9,147,1,148,1,148,
        3,148,1756,8,148,1,148,3,148,1759,8,148,1,148,3,148,1762,8,148,3,
        148,1764,8,148,1,148,3,148,1767,8,148,1,148,3,148,1770,8,148,1,148,
        1,148,3,148,1774,8,148,1,149,4,149,1777,8,149,11,149,12,149,1778,
        1,150,1,150,1,151,1,151,1,151,1,151,1,152,1,152,1,152,1,153,1,153,
        3,153,1792,8,153,1,153,1,153,1,153,3,153,1797,8,153,5,153,1799,8,
        153,10,153,12,153,1802,9,153,1,154,3,154,1805,8,154,1,154,1,154,
        1,154,3,154,1810,8,154,1,154,1,154,1,154,3,154,1815,8,154,1,154,
        1,154,3,154,1819,8,154,1,155,3,155,1822,8,155,1,155,1,155,3,155,
        1826,8,155,1,156,1,156,1,157,1,157,1,158,1,158,1,158,1,159,1,159,
        3,159,1837,8,159,1,160,1,160,3,160,1841,8,160,1,161,1,161,1,161,
        1,162,1,162,3,162,1848,8,162,1,162,1,162,1,162,3,162,1853,8,162,
        5,162,1855,8,162,10,162,12,162,1858,9,162,1,163,1,163,1,163,3,163,
        1863,8,163,1,163,1,163,3,163,1867,8,163,1,164,1,164,3,164,1871,8,
        164,1,165,1,165,1,165,1,166,1,166,1,166,1,166,3,166,1880,8,166,1,
        167,1,167,1,167,1,167,1,167,1,167,1,168,1,168,1,168,5,168,1891,8,
        168,10,168,12,168,1894,9,168,1,169,1,169,3,169,1898,8,169,1,170,
        1,170,1,170,1,170,1,170,3,170,1905,8,170,1,170,1,170,3,170,1909,
        8,170,1,170,3,170,1912,8,170,1,170,3,170,1915,8,170,1,170,3,170,
        1918,8,170,1,170,1,170,3,170,1922,8,170,1,171,1,171,1,171,3,171,
        1927,8,171,1,171,1,171,1,172,1,172,1,172,3,172,1934,8,172,1,172,
        1,172,3,172,1938,8,172,1,172,1,172,3,172,1942,8,172,1,173,1,173,
        1,174,1,174,3,174,1948,8,174,1,174,1,174,1,174,3,174,1953,8,174,
        5,174,1955,8,174,10,174,12,174,1958,9,174,1,175,1,175,1,175,3,175,
        1963,8,175,1,176,1,176,1,176,1,176,3,176,1969,8,176,1,176,3,176,
        1972,8,176,1,177,3,177,1975,8,177,1,177,1,177,1,177,1,178,1,178,
        1,178,1,178,1,178,1,179,1,179,1,179,1,179,1,180,1,180,3,180,1991,
        8,180,1,180,1,180,1,180,1,181,4,181,1997,8,181,11,181,12,181,1998,
        1,182,1,182,1,182,1,182,1,182,1,182,1,183,3,183,2008,8,183,1,183,
        1,183,1,183,3,183,2013,8,183,1,183,3,183,2016,8,183,1,184,1,184,
        3,184,2020,8,184,1,185,1,185,3,185,2024,8,185,1,186,1,186,1,186,
        3,186,2029,8,186,1,186,1,186,1,187,1,187,3,187,2035,8,187,1,187,
        1,187,1,187,3,187,2040,8,187,5,187,2042,8,187,10,187,12,187,2045,
        9,187,1,188,1,188,1,188,1,188,1,188,1,188,3,188,2053,8,188,1,189,
        1,189,1,189,3,189,2058,8,189,1,189,1,189,1,189,3,189,2063,8,189,
        1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
        1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
        1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
        1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,3,189,2106,8,189,
        1,190,1,190,1,190,1,1047,6,10,30,50,230,252,256,191,0,2,4,6,8,10,
        12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,
        56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,
        100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,
        132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,
        164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,
        196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,
        228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,
        260,262,264,266,268,270,272,274,276,278,280,282,284,286,288,290,
        292,294,296,298,300,302,304,306,308,310,312,314,316,318,320,322,
        324,326,328,330,332,334,336,338,340,342,344,346,348,350,352,354,
        356,358,360,362,364,366,368,370,372,374,376,378,380,0,23,2,0,97,
        97,101,101,4,0,24,24,31,31,58,58,65,65,2,0,124,124,129,129,1,0,120,
        121,2,0,91,93,97,100,2,0,123,123,130,130,1,0,93,95,1,0,91,92,2,0,
        102,103,116,117,1,0,114,115,2,0,101,101,104,113,5,0,36,36,47,47,
        57,57,63,63,70,70,3,0,34,34,44,44,80,80,2,0,46,46,60,60,2,0,61,61,
        78,78,2,0,21,21,66,66,1,0,85,90,2,0,97,97,118,118,2,0,22,22,82,82,
        1,0,27,28,2,0,38,38,53,53,1,0,54,56,1,0,1,7,2343,0,383,1,0,0,0,2,
        399,1,0,0,0,4,403,1,0,0,0,6,415,1,0,0,0,8,417,1,0,0,0,10,423,1,0,
        0,0,12,445,1,0,0,0,14,451,1,0,0,0,16,463,1,0,0,0,18,465,1,0,0,0,
        20,467,1,0,0,0,22,480,1,0,0,0,24,487,1,0,0,0,26,490,1,0,0,0,28,495,
        1,0,0,0,30,542,1,0,0,0,32,574,1,0,0,0,34,576,1,0,0,0,36,597,1,0,
        0,0,38,626,1,0,0,0,40,628,1,0,0,0,42,631,1,0,0,0,44,647,1,0,0,0,
        46,651,1,0,0,0,48,660,1,0,0,0,50,662,1,0,0,0,52,687,1,0,0,0,54,690,
        1,0,0,0,56,699,1,0,0,0,58,710,1,0,0,0,60,712,1,0,0,0,62,720,1,0,
        0,0,64,728,1,0,0,0,66,736,1,0,0,0,68,749,1,0,0,0,70,751,1,0,0,0,
        72,759,1,0,0,0,74,767,1,0,0,0,76,775,1,0,0,0,78,783,1,0,0,0,80,791,
        1,0,0,0,82,799,1,0,0,0,84,807,1,0,0,0,86,821,1,0,0,0,88,823,1,0,
        0,0,90,825,1,0,0,0,92,833,1,0,0,0,94,848,1,0,0,0,96,851,1,0,0,0,
        98,863,1,0,0,0,100,867,1,0,0,0,102,874,1,0,0,0,104,893,1,0,0,0,106,
        906,1,0,0,0,108,941,1,0,0,0,110,945,1,0,0,0,112,948,1,0,0,0,114,
        955,1,0,0,0,116,966,1,0,0,0,118,970,1,0,0,0,120,973,1,0,0,0,122,
        986,1,0,0,0,124,996,1,0,0,0,126,998,1,0,0,0,128,1021,1,0,0,0,130,
        1023,1,0,0,0,132,1031,1,0,0,0,134,1033,1,0,0,0,136,1042,1,0,0,0,
        138,1045,1,0,0,0,140,1052,1,0,0,0,142,1054,1,0,0,0,144,1056,1,0,
        0,0,146,1061,1,0,0,0,148,1067,1,0,0,0,150,1070,1,0,0,0,152,1078,
        1,0,0,0,154,1085,1,0,0,0,156,1087,1,0,0,0,158,1141,1,0,0,0,160,1147,
        1,0,0,0,162,1149,1,0,0,0,164,1179,1,0,0,0,166,1181,1,0,0,0,168,1183,
        1,0,0,0,170,1193,1,0,0,0,172,1206,1,0,0,0,174,1216,1,0,0,0,176,1220,
        1,0,0,0,178,1223,1,0,0,0,180,1231,1,0,0,0,182,1236,1,0,0,0,184,1240,
        1,0,0,0,186,1242,1,0,0,0,188,1245,1,0,0,0,190,1258,1,0,0,0,192,1260,
        1,0,0,0,194,1267,1,0,0,0,196,1271,1,0,0,0,198,1283,1,0,0,0,200,1293,
        1,0,0,0,202,1299,1,0,0,0,204,1310,1,0,0,0,206,1322,1,0,0,0,208,1324,
        1,0,0,0,210,1335,1,0,0,0,212,1349,1,0,0,0,214,1355,1,0,0,0,216,1357,
        1,0,0,0,218,1364,1,0,0,0,220,1385,1,0,0,0,222,1387,1,0,0,0,224,1395,
        1,0,0,0,226,1404,1,0,0,0,228,1412,1,0,0,0,230,1426,1,0,0,0,232,1445,
        1,0,0,0,234,1462,1,0,0,0,236,1481,1,0,0,0,238,1484,1,0,0,0,240,1488,
        1,0,0,0,242,1490,1,0,0,0,244,1493,1,0,0,0,246,1497,1,0,0,0,248,1509,
        1,0,0,0,250,1520,1,0,0,0,252,1536,1,0,0,0,254,1559,1,0,0,0,256,1564,
        1,0,0,0,258,1584,1,0,0,0,260,1591,1,0,0,0,262,1600,1,0,0,0,264,1614,
        1,0,0,0,266,1633,1,0,0,0,268,1640,1,0,0,0,270,1645,1,0,0,0,272,1649,
        1,0,0,0,274,1651,1,0,0,0,276,1665,1,0,0,0,278,1676,1,0,0,0,280,1678,
        1,0,0,0,282,1708,1,0,0,0,284,1711,1,0,0,0,286,1715,1,0,0,0,288,1717,
        1,0,0,0,290,1723,1,0,0,0,292,1743,1,0,0,0,294,1745,1,0,0,0,296,1773,
        1,0,0,0,298,1776,1,0,0,0,300,1780,1,0,0,0,302,1782,1,0,0,0,304,1786,
        1,0,0,0,306,1789,1,0,0,0,308,1804,1,0,0,0,310,1825,1,0,0,0,312,1827,
        1,0,0,0,314,1829,1,0,0,0,316,1831,1,0,0,0,318,1834,1,0,0,0,320,1838,
        1,0,0,0,322,1842,1,0,0,0,324,1845,1,0,0,0,326,1859,1,0,0,0,328,1870,
        1,0,0,0,330,1872,1,0,0,0,332,1875,1,0,0,0,334,1881,1,0,0,0,336,1887,
        1,0,0,0,338,1897,1,0,0,0,340,1908,1,0,0,0,342,1923,1,0,0,0,344,1941,
        1,0,0,0,346,1943,1,0,0,0,348,1945,1,0,0,0,350,1962,1,0,0,0,352,1964,
        1,0,0,0,354,1974,1,0,0,0,356,1979,1,0,0,0,358,1984,1,0,0,0,360,1988,
        1,0,0,0,362,1996,1,0,0,0,364,2000,1,0,0,0,366,2015,1,0,0,0,368,2017,
        1,0,0,0,370,2023,1,0,0,0,372,2025,1,0,0,0,374,2032,1,0,0,0,376,2052,
        1,0,0,0,378,2105,1,0,0,0,380,2107,1,0,0,0,382,384,3,120,60,0,383,
        382,1,0,0,0,383,384,1,0,0,0,384,385,1,0,0,0,385,386,5,0,0,1,386,
        1,1,0,0,0,387,389,3,380,190,0,388,387,1,0,0,0,389,390,1,0,0,0,390,
        388,1,0,0,0,390,391,1,0,0,0,391,400,1,0,0,0,392,400,5,69,0,0,393,
        394,5,85,0,0,394,395,3,90,45,0,395,396,5,86,0,0,396,400,1,0,0,0,
        397,400,3,4,2,0,398,400,3,12,6,0,399,388,1,0,0,0,399,392,1,0,0,0,
        399,393,1,0,0,0,399,397,1,0,0,0,399,398,1,0,0,0,400,3,1,0,0,0,401,
        404,3,6,3,0,402,404,3,8,4,0,403,401,1,0,0,0,403,402,1,0,0,0,404,
        5,1,0,0,0,405,416,5,132,0,0,406,416,3,330,165,0,407,416,3,316,158,
        0,408,416,3,332,166,0,409,412,5,99,0,0,410,413,3,278,139,0,411,413,
        3,162,81,0,412,410,1,0,0,0,412,411,1,0,0,0,413,416,1,0,0,0,414,416,
        3,344,172,0,415,405,1,0,0,0,415,406,1,0,0,0,415,407,1,0,0,0,415,
        408,1,0,0,0,415,409,1,0,0,0,415,414,1,0,0,0,416,7,1,0,0,0,417,419,
        3,10,5,0,418,420,5,68,0,0,419,418,1,0,0,0,419,420,1,0,0,0,420,421,
        1,0,0,0,421,422,3,6,3,0,422,9,1,0,0,0,423,427,6,5,-1,0,424,428,3,
        160,80,0,425,428,3,184,92,0,426,428,3,162,81,0,427,424,1,0,0,0,427,
        425,1,0,0,0,427,426,1,0,0,0,427,428,1,0,0,0,428,429,1,0,0,0,429,
        430,5,127,0,0,430,442,1,0,0,0,431,437,10,1,0,0,432,438,5,132,0,0,
        433,435,5,68,0,0,434,433,1,0,0,0,434,435,1,0,0,0,435,436,1,0,0,0,
        436,438,3,342,171,0,437,432,1,0,0,0,437,434,1,0,0,0,438,439,1,0,
        0,0,439,441,5,127,0,0,440,431,1,0,0,0,441,444,1,0,0,0,442,440,1,
        0,0,0,442,443,1,0,0,0,443,11,1,0,0,0,444,442,1,0,0,0,445,447,3,14,
        7,0,446,448,3,28,14,0,447,446,1,0,0,0,447,448,1,0,0,0,448,449,1,
        0,0,0,449,450,3,100,50,0,450,13,1,0,0,0,451,453,5,87,0,0,452,454,
        3,16,8,0,453,452,1,0,0,0,453,454,1,0,0,0,454,455,1,0,0,0,455,456,
        5,88,0,0,456,15,1,0,0,0,457,464,3,20,10,0,458,461,3,18,9,0,459,460,
        5,122,0,0,460,462,3,20,10,0,461,459,1,0,0,0,461,462,1,0,0,0,462,
        464,1,0,0,0,463,457,1,0,0,0,463,458,1,0,0,0,464,17,1,0,0,0,465,466,
        7,0,0,0,466,19,1,0,0,0,467,472,3,22,11,0,468,469,5,122,0,0,469,471,
        3,22,11,0,470,468,1,0,0,0,471,474,1,0,0,0,472,470,1,0,0,0,472,473,
        1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,475,477,5,131,0,0,476,475,
        1,0,0,0,476,477,1,0,0,0,477,21,1,0,0,0,478,481,3,24,12,0,479,481,
        3,26,13,0,480,478,1,0,0,0,480,479,1,0,0,0,481,23,1,0,0,0,482,484,
        5,97,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,485,1,0,0,0,485,488,
        5,132,0,0,486,488,5,69,0,0,487,483,1,0,0,0,487,486,1,0,0,0,488,25,
        1,0,0,0,489,491,5,97,0,0,490,489,1,0,0,0,490,491,1,0,0,0,491,492,
        1,0,0,0,492,493,5,132,0,0,493,494,3,268,134,0,494,27,1,0,0,0,495,
        497,5,85,0,0,496,498,3,258,129,0,497,496,1,0,0,0,497,498,1,0,0,0,
        498,499,1,0,0,0,499,501,5,86,0,0,500,502,5,47,0,0,501,500,1,0,0,
        0,501,502,1,0,0,0,502,504,1,0,0,0,503,505,3,370,185,0,504,503,1,
        0,0,0,504,505,1,0,0,0,505,507,1,0,0,0,506,508,3,204,102,0,507,506,
        1,0,0,0,507,508,1,0,0,0,508,510,1,0,0,0,509,511,3,234,117,0,510,
        509,1,0,0,0,510,511,1,0,0,0,511,29,1,0,0,0,512,513,6,15,-1,0,513,
        543,3,2,1,0,514,517,3,158,79,0,515,517,3,352,176,0,516,514,1,0,0,
        0,516,515,1,0,0,0,517,524,1,0,0,0,518,520,5,85,0,0,519,521,3,34,
        17,0,520,519,1,0,0,0,520,521,1,0,0,0,521,522,1,0,0,0,522,525,5,86,
        0,0,523,525,3,276,138,0,524,518,1,0,0,0,524,523,1,0,0,0,525,543,
        1,0,0,0,526,527,7,1,0,0,527,528,5,102,0,0,528,529,3,246,123,0,529,
        530,5,103,0,0,530,531,5,85,0,0,531,532,3,90,45,0,532,533,5,86,0,
        0,533,543,1,0,0,0,534,535,3,32,16,0,535,538,5,85,0,0,536,539,3,90,
        45,0,537,539,3,246,123,0,538,536,1,0,0,0,538,537,1,0,0,0,539,540,
        1,0,0,0,540,541,5,86,0,0,541,543,1,0,0,0,542,512,1,0,0,0,542,516,
        1,0,0,0,542,526,1,0,0,0,542,534,1,0,0,0,543,571,1,0,0,0,544,545,
        10,7,0,0,545,548,5,87,0,0,546,549,3,90,45,0,547,549,3,276,138,0,
        548,546,1,0,0,0,548,547,1,0,0,0,549,550,1,0,0,0,550,551,5,88,0,0,
        551,570,1,0,0,0,552,553,10,6,0,0,553,555,5,85,0,0,554,556,3,34,17,
        0,555,554,1,0,0,0,555,556,1,0,0,0,556,557,1,0,0,0,557,570,5,86,0,
        0,558,559,10,4,0,0,559,565,7,2,0,0,560,562,5,68,0,0,561,560,1,0,
        0,0,561,562,1,0,0,0,562,563,1,0,0,0,563,566,3,4,2,0,564,566,3,36,
        18,0,565,561,1,0,0,0,565,564,1,0,0,0,566,570,1,0,0,0,567,568,10,
        3,0,0,568,570,7,3,0,0,569,544,1,0,0,0,569,552,1,0,0,0,569,558,1,
        0,0,0,569,567,1,0,0,0,570,573,1,0,0,0,571,569,1,0,0,0,571,572,1,
        0,0,0,572,31,1,0,0,0,573,571,1,0,0,0,574,575,5,75,0,0,575,33,1,0,
        0,0,576,577,3,274,137,0,577,35,1,0,0,0,578,580,3,10,5,0,579,578,
        1,0,0,0,579,580,1,0,0,0,580,584,1,0,0,0,581,582,3,160,80,0,582,583,
        5,127,0,0,583,585,1,0,0,0,584,581,1,0,0,0,584,585,1,0,0,0,585,586,
        1,0,0,0,586,587,5,99,0,0,587,598,3,160,80,0,588,589,3,10,5,0,589,
        590,5,68,0,0,590,591,3,342,171,0,591,592,5,127,0,0,592,593,5,99,
        0,0,593,594,3,160,80,0,594,598,1,0,0,0,595,596,5,99,0,0,596,598,
        3,162,81,0,597,579,1,0,0,0,597,588,1,0,0,0,597,595,1,0,0,0,598,37,
        1,0,0,0,599,627,3,30,15,0,600,605,5,120,0,0,601,605,5,121,0,0,602,
        605,3,40,20,0,603,605,5,62,0,0,604,600,1,0,0,0,604,601,1,0,0,0,604,
        602,1,0,0,0,604,603,1,0,0,0,605,606,1,0,0,0,606,627,3,38,19,0,607,
        616,5,62,0,0,608,609,5,85,0,0,609,610,3,246,123,0,610,611,5,86,0,
        0,611,617,1,0,0,0,612,613,5,131,0,0,613,614,5,85,0,0,614,615,5,132,
        0,0,615,617,5,86,0,0,616,608,1,0,0,0,616,612,1,0,0,0,617,627,1,0,
        0,0,618,619,5,11,0,0,619,620,5,85,0,0,620,621,3,246,123,0,621,622,
        5,86,0,0,622,627,1,0,0,0,623,627,3,56,28,0,624,627,3,42,21,0,625,
        627,3,54,27,0,626,599,1,0,0,0,626,604,1,0,0,0,626,607,1,0,0,0,626,
        618,1,0,0,0,626,623,1,0,0,0,626,624,1,0,0,0,626,625,1,0,0,0,627,
        39,1,0,0,0,628,629,7,4,0,0,629,41,1,0,0,0,630,632,5,127,0,0,631,
        630,1,0,0,0,631,632,1,0,0,0,632,633,1,0,0,0,633,635,5,49,0,0,634,
        636,3,44,22,0,635,634,1,0,0,0,635,636,1,0,0,0,636,642,1,0,0,0,637,
        643,3,46,23,0,638,639,5,85,0,0,639,640,3,246,123,0,640,641,5,86,
        0,0,641,643,1,0,0,0,642,637,1,0,0,0,642,638,1,0,0,0,643,645,1,0,
        0,0,644,646,3,52,26,0,645,644,1,0,0,0,645,646,1,0,0,0,646,43,1,0,
        0,0,647,648,5,85,0,0,648,649,3,34,17,0,649,650,5,86,0,0,650,45,1,
        0,0,0,651,653,3,150,75,0,652,654,3,48,24,0,653,652,1,0,0,0,653,654,
        1,0,0,0,654,47,1,0,0,0,655,657,3,236,118,0,656,658,3,48,24,0,657,
        656,1,0,0,0,657,658,1,0,0,0,658,661,1,0,0,0,659,661,3,50,25,0,660,
        655,1,0,0,0,660,659,1,0,0,0,661,49,1,0,0,0,662,663,6,25,-1,0,663,
        664,5,87,0,0,664,665,3,90,45,0,665,667,5,88,0,0,666,668,3,204,102,
        0,667,666,1,0,0,0,667,668,1,0,0,0,668,678,1,0,0,0,669,670,10,1,0,
        0,670,671,5,87,0,0,671,672,3,92,46,0,672,674,5,88,0,0,673,675,3,
        204,102,0,674,673,1,0,0,0,674,675,1,0,0,0,675,677,1,0,0,0,676,669,
        1,0,0,0,677,680,1,0,0,0,678,676,1,0,0,0,678,679,1,0,0,0,679,51,1,
        0,0,0,680,678,1,0,0,0,681,683,5,85,0,0,682,684,3,34,17,0,683,682,
        1,0,0,0,683,684,1,0,0,0,684,685,1,0,0,0,685,688,5,86,0,0,686,688,
        3,276,138,0,687,681,1,0,0,0,687,686,1,0,0,0,688,53,1,0,0,0,689,691,
        5,127,0,0,690,689,1,0,0,0,690,691,1,0,0,0,691,692,1,0,0,0,692,695,
        5,28,0,0,693,694,5,87,0,0,694,696,5,88,0,0,695,693,1,0,0,0,695,696,
        1,0,0,0,696,697,1,0,0,0,697,698,3,58,29,0,698,55,1,0,0,0,699,700,
        5,50,0,0,700,701,5,85,0,0,701,702,3,90,45,0,702,703,5,86,0,0,703,
        57,1,0,0,0,704,711,3,38,19,0,705,706,5,85,0,0,706,707,3,246,123,
        0,707,708,5,86,0,0,708,709,3,58,29,0,709,711,1,0,0,0,710,704,1,0,
        0,0,710,705,1,0,0,0,711,59,1,0,0,0,712,717,3,58,29,0,713,714,7,5,
        0,0,714,716,3,58,29,0,715,713,1,0,0,0,716,719,1,0,0,0,717,715,1,
        0,0,0,717,718,1,0,0,0,718,61,1,0,0,0,719,717,1,0,0,0,720,725,3,60,
        30,0,721,722,7,6,0,0,722,724,3,60,30,0,723,721,1,0,0,0,724,727,1,
        0,0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,63,1,0,0,0,727,725,1,0,
        0,0,728,733,3,62,31,0,729,730,7,7,0,0,730,732,3,62,31,0,731,729,
        1,0,0,0,732,735,1,0,0,0,733,731,1,0,0,0,733,734,1,0,0,0,734,65,1,
        0,0,0,735,733,1,0,0,0,736,742,3,64,32,0,737,738,3,68,34,0,738,739,
        3,64,32,0,739,741,1,0,0,0,740,737,1,0,0,0,741,744,1,0,0,0,742,740,
        1,0,0,0,742,743,1,0,0,0,743,67,1,0,0,0,744,742,1,0,0,0,745,746,5,
        103,0,0,746,750,5,103,0,0,747,748,5,102,0,0,748,750,5,102,0,0,749,
        745,1,0,0,0,749,747,1,0,0,0,750,69,1,0,0,0,751,756,3,66,33,0,752,
        753,7,8,0,0,753,755,3,66,33,0,754,752,1,0,0,0,755,758,1,0,0,0,756,
        754,1,0,0,0,756,757,1,0,0,0,757,71,1,0,0,0,758,756,1,0,0,0,759,764,
        3,70,35,0,760,761,7,9,0,0,761,763,3,70,35,0,762,760,1,0,0,0,763,
        766,1,0,0,0,764,762,1,0,0,0,764,765,1,0,0,0,765,73,1,0,0,0,766,764,
        1,0,0,0,767,772,3,72,36,0,768,769,5,97,0,0,769,771,3,72,36,0,770,
        768,1,0,0,0,771,774,1,0,0,0,772,770,1,0,0,0,772,773,1,0,0,0,773,
        75,1,0,0,0,774,772,1,0,0,0,775,780,3,74,37,0,776,777,5,96,0,0,777,
        779,3,74,37,0,778,776,1,0,0,0,779,782,1,0,0,0,780,778,1,0,0,0,780,
        781,1,0,0,0,781,77,1,0,0,0,782,780,1,0,0,0,783,788,3,76,38,0,784,
        785,5,98,0,0,785,787,3,76,38,0,786,784,1,0,0,0,787,790,1,0,0,0,788,
        786,1,0,0,0,788,789,1,0,0,0,789,79,1,0,0,0,790,788,1,0,0,0,791,796,
        3,78,39,0,792,793,5,118,0,0,793,795,3,78,39,0,794,792,1,0,0,0,795,
        798,1,0,0,0,796,794,1,0,0,0,796,797,1,0,0,0,797,81,1,0,0,0,798,796,
        1,0,0,0,799,804,3,80,40,0,800,801,5,119,0,0,801,803,3,80,40,0,802,
        800,1,0,0,0,803,806,1,0,0,0,804,802,1,0,0,0,804,805,1,0,0,0,805,
        83,1,0,0,0,806,804,1,0,0,0,807,813,3,82,41,0,808,809,5,125,0,0,809,
        810,3,90,45,0,810,811,5,126,0,0,811,812,3,86,43,0,812,814,1,0,0,
        0,813,808,1,0,0,0,813,814,1,0,0,0,814,85,1,0,0,0,815,822,3,84,42,
        0,816,817,3,82,41,0,817,818,3,88,44,0,818,819,3,272,136,0,819,822,
        1,0,0,0,820,822,3,368,184,0,821,815,1,0,0,0,821,816,1,0,0,0,821,
        820,1,0,0,0,822,87,1,0,0,0,823,824,7,10,0,0,824,89,1,0,0,0,825,830,
        3,86,43,0,826,827,5,122,0,0,827,829,3,86,43,0,828,826,1,0,0,0,829,
        832,1,0,0,0,830,828,1,0,0,0,830,831,1,0,0,0,831,91,1,0,0,0,832,830,
        1,0,0,0,833,834,3,84,42,0,834,93,1,0,0,0,835,849,3,96,48,0,836,849,
        3,118,59,0,837,839,3,204,102,0,838,837,1,0,0,0,838,839,1,0,0,0,839,
        846,1,0,0,0,840,847,3,98,49,0,841,847,3,100,50,0,842,847,3,104,52,
        0,843,847,3,108,54,0,844,847,3,116,58,0,845,847,3,358,179,0,846,
        840,1,0,0,0,846,841,1,0,0,0,846,842,1,0,0,0,846,843,1,0,0,0,846,
        844,1,0,0,0,846,845,1,0,0,0,847,849,1,0,0,0,848,835,1,0,0,0,848,
        836,1,0,0,0,848,838,1,0,0,0,849,95,1,0,0,0,850,852,3,204,102,0,851,
        850,1,0,0,0,851,852,1,0,0,0,852,857,1,0,0,0,853,858,5,132,0,0,854,
        855,5,16,0,0,855,858,3,92,46,0,856,858,5,27,0,0,857,853,1,0,0,0,
        857,854,1,0,0,0,857,856,1,0,0,0,858,859,1,0,0,0,859,860,5,126,0,
        0,860,861,3,94,47,0,861,97,1,0,0,0,862,864,3,90,45,0,863,862,1,0,
        0,0,863,864,1,0,0,0,864,865,1,0,0,0,865,866,5,128,0,0,866,99,1,0,
        0,0,867,869,5,89,0,0,868,870,3,102,51,0,869,868,1,0,0,0,869,870,
        1,0,0,0,870,871,1,0,0,0,871,872,5,90,0,0,872,101,1,0,0,0,873,875,
        3,94,47,0,874,873,1,0,0,0,875,876,1,0,0,0,876,874,1,0,0,0,876,877,
        1,0,0,0,877,103,1,0,0,0,878,879,5,43,0,0,879,880,5,85,0,0,880,881,
        3,106,53,0,881,882,5,86,0,0,882,885,3,94,47,0,883,884,5,32,0,0,884,
        886,3,94,47,0,885,883,1,0,0,0,885,886,1,0,0,0,886,894,1,0,0,0,887,
        888,5,67,0,0,888,889,5,85,0,0,889,890,3,106,53,0,890,891,5,86,0,
        0,891,892,3,94,47,0,892,894,1,0,0,0,893,878,1,0,0,0,893,887,1,0,
        0,0,894,105,1,0,0,0,895,907,3,90,45,0,896,898,3,204,102,0,897,896,
        1,0,0,0,897,898,1,0,0,0,898,899,1,0,0,0,899,900,3,138,69,0,900,904,
        3,226,113,0,901,902,5,101,0,0,902,905,3,272,136,0,903,905,3,276,
        138,0,904,901,1,0,0,0,904,903,1,0,0,0,905,907,1,0,0,0,906,895,1,
        0,0,0,906,897,1,0,0,0,907,107,1,0,0,0,908,909,5,84,0,0,909,910,5,
        85,0,0,910,911,3,106,53,0,911,912,5,86,0,0,912,913,3,94,47,0,913,
        942,1,0,0,0,914,915,5,29,0,0,915,916,3,94,47,0,916,917,5,84,0,0,
        917,918,5,85,0,0,918,919,3,90,45,0,919,920,5,86,0,0,920,921,5,128,
        0,0,921,942,1,0,0,0,922,923,5,40,0,0,923,936,5,85,0,0,924,926,3,
        110,55,0,925,927,3,106,53,0,926,925,1,0,0,0,926,927,1,0,0,0,927,
        928,1,0,0,0,928,930,5,128,0,0,929,931,3,90,45,0,930,929,1,0,0,0,
        930,931,1,0,0,0,931,937,1,0,0,0,932,933,3,112,56,0,933,934,5,126,
        0,0,934,935,3,114,57,0,935,937,1,0,0,0,936,924,1,0,0,0,936,932,1,
        0,0,0,937,938,1,0,0,0,938,939,5,86,0,0,939,940,3,94,47,0,940,942,
        1,0,0,0,941,908,1,0,0,0,941,914,1,0,0,0,941,922,1,0,0,0,942,109,
        1,0,0,0,943,946,3,98,49,0,944,946,3,128,64,0,945,943,1,0,0,0,945,
        944,1,0,0,0,946,111,1,0,0,0,947,949,3,204,102,0,948,947,1,0,0,0,
        948,949,1,0,0,0,949,950,1,0,0,0,950,951,3,138,69,0,951,952,3,226,
        113,0,952,113,1,0,0,0,953,956,3,90,45,0,954,956,3,276,138,0,955,
        953,1,0,0,0,955,954,1,0,0,0,956,115,1,0,0,0,957,967,5,15,0,0,958,
        967,5,25,0,0,959,962,5,59,0,0,960,963,3,90,45,0,961,963,3,276,138,
        0,962,960,1,0,0,0,962,961,1,0,0,0,962,963,1,0,0,0,963,967,1,0,0,
        0,964,965,5,42,0,0,965,967,5,132,0,0,966,957,1,0,0,0,966,958,1,0,
        0,0,966,959,1,0,0,0,966,964,1,0,0,0,967,968,1,0,0,0,968,969,5,128,
        0,0,969,117,1,0,0,0,970,971,3,124,62,0,971,119,1,0,0,0,972,974,3,
        122,61,0,973,972,1,0,0,0,974,975,1,0,0,0,975,973,1,0,0,0,975,976,
        1,0,0,0,976,121,1,0,0,0,977,987,3,124,62,0,978,987,3,264,132,0,979,
        987,3,334,167,0,980,987,3,354,177,0,981,987,3,356,178,0,982,987,
        3,202,101,0,983,987,3,188,94,0,984,987,3,132,66,0,985,987,3,134,
        67,0,986,977,1,0,0,0,986,978,1,0,0,0,986,979,1,0,0,0,986,980,1,0,
        0,0,986,981,1,0,0,0,986,982,1,0,0,0,986,983,1,0,0,0,986,984,1,0,
        0,0,986,985,1,0,0,0,987,123,1,0,0,0,988,997,3,128,64,0,989,997,3,
        200,100,0,990,997,3,192,96,0,991,997,3,196,98,0,992,997,3,198,99,
        0,993,997,3,130,65,0,994,997,3,126,63,0,995,997,3,172,86,0,996,988,
        1,0,0,0,996,989,1,0,0,0,996,990,1,0,0,0,996,991,1,0,0,0,996,992,
        1,0,0,0,996,993,1,0,0,0,996,994,1,0,0,0,996,995,1,0,0,0,997,125,
        1,0,0,0,998,999,5,79,0,0,999,1001,5,132,0,0,1000,1002,3,204,102,
        0,1001,1000,1,0,0,0,1001,1002,1,0,0,0,1002,1003,1,0,0,0,1003,1004,
        5,101,0,0,1004,1005,3,246,123,0,1005,1006,5,128,0,0,1006,127,1,0,
        0,0,1007,1009,3,138,69,0,1008,1007,1,0,0,0,1008,1009,1,0,0,0,1009,
        1011,1,0,0,0,1010,1012,3,222,111,0,1011,1010,1,0,0,0,1011,1012,1,
        0,0,0,1012,1013,1,0,0,0,1013,1022,5,128,0,0,1014,1016,3,204,102,
        0,1015,1017,3,138,69,0,1016,1015,1,0,0,0,1016,1017,1,0,0,0,1017,
        1018,1,0,0,0,1018,1019,3,222,111,0,1019,1020,5,128,0,0,1020,1022,
        1,0,0,0,1021,1008,1,0,0,0,1021,1014,1,0,0,0,1022,129,1,0,0,0,1023,
        1024,5,64,0,0,1024,1025,5,85,0,0,1025,1026,3,92,46,0,1026,1027,5,
        122,0,0,1027,1028,5,4,0,0,1028,1029,5,86,0,0,1029,1030,5,128,0,0,
        1030,131,1,0,0,0,1031,1032,5,128,0,0,1032,133,1,0,0,0,1033,1034,
        3,204,102,0,1034,1035,5,128,0,0,1035,135,1,0,0,0,1036,1043,3,140,
        70,0,1037,1043,3,146,73,0,1038,1043,3,142,71,0,1039,1043,5,41,0,
        0,1040,1043,5,74,0,0,1041,1043,5,23,0,0,1042,1036,1,0,0,0,1042,1037,
        1,0,0,0,1042,1038,1,0,0,0,1042,1039,1,0,0,0,1042,1040,1,0,0,0,1042,
        1041,1,0,0,0,1043,137,1,0,0,0,1044,1046,3,136,68,0,1045,1044,1,0,
        0,0,1046,1047,1,0,0,0,1047,1048,1,0,0,0,1047,1045,1,0,0,0,1048,1050,
        1,0,0,0,1049,1051,3,204,102,0,1050,1049,1,0,0,0,1050,1051,1,0,0,
        0,1051,139,1,0,0,0,1052,1053,7,11,0,0,1053,141,1,0,0,0,1054,1055,
        7,12,0,0,1055,143,1,0,0,0,1056,1057,5,132,0,0,1057,145,1,0,0,0,1058,
        1062,3,148,74,0,1059,1062,3,280,140,0,1060,1062,3,168,84,0,1061,
        1058,1,0,0,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0,1062,147,1,0,0,
        0,1063,1068,3,158,79,0,1064,1068,3,164,82,0,1065,1068,3,352,176,
        0,1066,1068,3,240,120,0,1067,1063,1,0,0,0,1067,1064,1,0,0,0,1067,
        1065,1,0,0,0,1067,1066,1,0,0,0,1068,149,1,0,0,0,1069,1071,3,146,
        73,0,1070,1069,1,0,0,0,1071,1072,1,0,0,0,1072,1070,1,0,0,0,1072,
        1073,1,0,0,0,1073,1075,1,0,0,0,1074,1076,3,204,102,0,1075,1074,1,
        0,0,0,1075,1076,1,0,0,0,1076,151,1,0,0,0,1077,1079,3,148,74,0,1078,
        1077,1,0,0,0,1079,1080,1,0,0,0,1080,1078,1,0,0,0,1080,1081,1,0,0,
        0,1081,1083,1,0,0,0,1082,1084,3,204,102,0,1083,1082,1,0,0,0,1083,
        1084,1,0,0,0,1084,153,1,0,0,0,1085,1086,7,13,0,0,1086,155,1,0,0,
        0,1087,1088,7,14,0,0,1088,157,1,0,0,0,1089,1091,3,10,5,0,1090,1089,
        1,0,0,0,1090,1091,1,0,0,0,1091,1092,1,0,0,0,1092,1142,3,160,80,0,
        1093,1094,3,10,5,0,1094,1095,5,68,0,0,1095,1096,3,342,171,0,1096,
        1142,1,0,0,0,1097,1142,3,156,78,0,1098,1100,3,156,78,0,1099,1098,
        1,0,0,0,1099,1100,1,0,0,0,1100,1102,1,0,0,0,1101,1103,3,154,77,0,
        1102,1101,1,0,0,0,1103,1104,1,0,0,0,1104,1102,1,0,0,0,1104,1105,
        1,0,0,0,1105,1142,1,0,0,0,1106,1108,3,156,78,0,1107,1106,1,0,0,0,
        1107,1108,1,0,0,0,1108,1109,1,0,0,0,1109,1142,5,18,0,0,1110,1112,
        3,156,78,0,1111,1110,1,0,0,0,1111,1112,1,0,0,0,1112,1113,1,0,0,0,
        1113,1142,5,19,0,0,1114,1116,3,156,78,0,1115,1114,1,0,0,0,1115,1116,
        1,0,0,0,1116,1117,1,0,0,0,1117,1142,5,20,0,0,1118,1120,3,156,78,
        0,1119,1118,1,0,0,0,1119,1120,1,0,0,0,1120,1121,1,0,0,0,1121,1142,
        5,83,0,0,1122,1142,5,14,0,0,1123,1125,3,156,78,0,1124,1123,1,0,0,
        0,1124,1125,1,0,0,0,1125,1129,1,0,0,0,1126,1128,3,154,77,0,1127,
        1126,1,0,0,0,1128,1131,1,0,0,0,1129,1127,1,0,0,0,1129,1130,1,0,0,
        0,1130,1132,1,0,0,0,1131,1129,1,0,0,0,1132,1142,5,45,0,0,1133,1142,
        5,39,0,0,1134,1136,3,154,77,0,1135,1134,1,0,0,0,1135,1136,1,0,0,
        0,1136,1137,1,0,0,0,1137,1142,5,30,0,0,1138,1142,5,81,0,0,1139,1142,
        5,13,0,0,1140,1142,3,162,81,0,1141,1090,1,0,0,0,1141,1093,1,0,0,
        0,1141,1097,1,0,0,0,1141,1099,1,0,0,0,1141,1107,1,0,0,0,1141,1111,
        1,0,0,0,1141,1115,1,0,0,0,1141,1119,1,0,0,0,1141,1122,1,0,0,0,1141,
        1124,1,0,0,0,1141,1133,1,0,0,0,1141,1135,1,0,0,0,1141,1138,1,0,0,
        0,1141,1139,1,0,0,0,1141,1140,1,0,0,0,1142,159,1,0,0,0,1143,1148,
        3,278,139,0,1144,1148,3,166,83,0,1145,1148,3,144,72,0,1146,1148,
        3,342,171,0,1147,1143,1,0,0,0,1147,1144,1,0,0,0,1147,1145,1,0,0,
        0,1147,1146,1,0,0,0,1148,161,1,0,0,0,1149,1150,5,26,0,0,1150,1153,
        5,85,0,0,1151,1154,3,90,45,0,1152,1154,5,13,0,0,1153,1151,1,0,0,
        0,1153,1152,1,0,0,0,1154,1155,1,0,0,0,1155,1156,5,86,0,0,1156,163,
        1,0,0,0,1157,1172,3,288,144,0,1158,1160,3,204,102,0,1159,1158,1,
        0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161,1163,3,10,5,0,1162,
        1161,1,0,0,0,1162,1163,1,0,0,0,1163,1164,1,0,0,0,1164,1173,5,132,
        0,0,1165,1173,3,342,171,0,1166,1168,3,10,5,0,1167,1169,5,68,0,0,
        1168,1167,1,0,0,0,1168,1169,1,0,0,0,1169,1170,1,0,0,0,1170,1171,
        3,342,171,0,1171,1173,1,0,0,0,1172,1159,1,0,0,0,1172,1165,1,0,0,
        0,1172,1166,1,0,0,0,1173,1180,1,0,0,0,1174,1176,5,33,0,0,1175,1177,
        3,10,5,0,1176,1175,1,0,0,0,1176,1177,1,0,0,0,1177,1178,1,0,0,0,1178,
        1180,5,132,0,0,1179,1157,1,0,0,0,1179,1174,1,0,0,0,1180,165,1,0,
        0,0,1181,1182,5,132,0,0,1182,167,1,0,0,0,1183,1184,3,170,85,0,1184,
        1189,5,89,0,0,1185,1187,3,178,89,0,1186,1188,5,122,0,0,1187,1186,
        1,0,0,0,1187,1188,1,0,0,0,1188,1190,1,0,0,0,1189,1185,1,0,0,0,1189,
        1190,1,0,0,0,1190,1191,1,0,0,0,1191,1192,5,90,0,0,1192,169,1,0,0,
        0,1193,1195,3,174,87,0,1194,1196,3,204,102,0,1195,1194,1,0,0,0,1195,
        1196,1,0,0,0,1196,1201,1,0,0,0,1197,1199,3,10,5,0,1198,1197,1,0,
        0,0,1198,1199,1,0,0,0,1199,1200,1,0,0,0,1200,1202,5,132,0,0,1201,
        1198,1,0,0,0,1201,1202,1,0,0,0,1202,1204,1,0,0,0,1203,1205,3,176,
        88,0,1204,1203,1,0,0,0,1204,1205,1,0,0,0,1205,171,1,0,0,0,1206,1208,
        3,174,87,0,1207,1209,3,204,102,0,1208,1207,1,0,0,0,1208,1209,1,0,
        0,0,1209,1210,1,0,0,0,1210,1212,5,132,0,0,1211,1213,3,176,88,0,1212,
        1211,1,0,0,0,1212,1213,1,0,0,0,1213,1214,1,0,0,0,1214,1215,5,128,
        0,0,1215,173,1,0,0,0,1216,1218,5,33,0,0,1217,1219,7,15,0,0,1218,
        1217,1,0,0,0,1218,1219,1,0,0,0,1219,175,1,0,0,0,1220,1221,5,126,
        0,0,1221,1222,3,150,75,0,1222,177,1,0,0,0,1223,1228,3,180,90,0,1224,
        1225,5,122,0,0,1225,1227,3,180,90,0,1226,1224,1,0,0,0,1227,1230,
        1,0,0,0,1228,1226,1,0,0,0,1228,1229,1,0,0,0,1229,179,1,0,0,0,1230,
        1228,1,0,0,0,1231,1234,3,182,91,0,1232,1233,5,101,0,0,1233,1235,
        3,92,46,0,1234,1232,1,0,0,0,1234,1235,1,0,0,0,1235,181,1,0,0,0,1236,
        1237,5,132,0,0,1237,183,1,0,0,0,1238,1241,3,186,93,0,1239,1241,3,
        190,95,0,1240,1238,1,0,0,0,1240,1239,1,0,0,0,1241,185,1,0,0,0,1242,
        1243,5,132,0,0,1243,187,1,0,0,0,1244,1246,5,44,0,0,1245,1244,1,0,
        0,0,1245,1246,1,0,0,0,1246,1247,1,0,0,0,1247,1250,5,48,0,0,1248,
        1251,5,132,0,0,1249,1251,3,186,93,0,1250,1248,1,0,0,0,1250,1249,
        1,0,0,0,1250,1251,1,0,0,0,1251,1252,1,0,0,0,1252,1254,5,89,0,0,1253,
        1255,3,120,60,0,1254,1253,1,0,0,0,1254,1255,1,0,0,0,1255,1256,1,
        0,0,0,1256,1257,5,90,0,0,1257,189,1,0,0,0,1258,1259,5,132,0,0,1259,
        191,1,0,0,0,1260,1261,5,48,0,0,1261,1262,5,132,0,0,1262,1263,5,101,
        0,0,1263,1264,3,194,97,0,1264,1265,5,128,0,0,1265,193,1,0,0,0,1266,
        1268,3,10,5,0,1267,1266,1,0,0,0,1267,1268,1,0,0,0,1268,1269,1,0,
        0,0,1269,1270,3,184,92,0,1270,195,1,0,0,0,1271,1277,5,79,0,0,1272,
        1274,5,76,0,0,1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274,1275,1,0,
        0,0,1275,1278,3,10,5,0,1276,1278,5,127,0,0,1277,1273,1,0,0,0,1277,
        1276,1,0,0,0,1278,1279,1,0,0,0,1279,1280,3,6,3,0,1280,1281,5,128,
        0,0,1281,197,1,0,0,0,1282,1284,3,204,102,0,1283,1282,1,0,0,0,1283,
        1284,1,0,0,0,1284,1285,1,0,0,0,1285,1286,5,79,0,0,1286,1288,5,48,
        0,0,1287,1289,3,10,5,0,1288,1287,1,0,0,0,1288,1289,1,0,0,0,1289,
        1290,1,0,0,0,1290,1291,3,184,92,0,1291,1292,5,128,0,0,1292,199,1,
        0,0,0,1293,1294,5,12,0,0,1294,1295,5,85,0,0,1295,1296,5,4,0,0,1296,
        1297,5,86,0,0,1297,1298,5,128,0,0,1298,201,1,0,0,0,1299,1300,5,36,
        0,0,1300,1307,5,4,0,0,1301,1303,5,89,0,0,1302,1304,3,120,60,0,1303,
        1302,1,0,0,0,1303,1304,1,0,0,0,1304,1305,1,0,0,0,1305,1308,5,90,
        0,0,1306,1308,3,122,61,0,1307,1301,1,0,0,0,1307,1306,1,0,0,0,1308,
        203,1,0,0,0,1309,1311,3,206,103,0,1310,1309,1,0,0,0,1311,1312,1,
        0,0,0,1312,1310,1,0,0,0,1312,1313,1,0,0,0,1313,205,1,0,0,0,1314,
        1315,5,87,0,0,1315,1317,5,87,0,0,1316,1318,3,210,105,0,1317,1316,
        1,0,0,0,1317,1318,1,0,0,0,1318,1319,1,0,0,0,1319,1320,5,88,0,0,1320,
        1323,5,88,0,0,1321,1323,3,208,104,0,1322,1314,1,0,0,0,1322,1321,
        1,0,0,0,1323,207,1,0,0,0,1324,1325,5,10,0,0,1325,1328,5,85,0,0,1326,
        1329,3,246,123,0,1327,1329,3,92,46,0,1328,1326,1,0,0,0,1328,1327,
        1,0,0,0,1329,1331,1,0,0,0,1330,1332,5,131,0,0,1331,1330,1,0,0,0,
        1331,1332,1,0,0,0,1332,1333,1,0,0,0,1333,1334,5,86,0,0,1334,209,
        1,0,0,0,1335,1340,3,212,106,0,1336,1337,5,122,0,0,1337,1339,3,212,
        106,0,1338,1336,1,0,0,0,1339,1342,1,0,0,0,1340,1338,1,0,0,0,1340,
        1341,1,0,0,0,1341,1344,1,0,0,0,1342,1340,1,0,0,0,1343,1345,5,131,
        0,0,1344,1343,1,0,0,0,1344,1345,1,0,0,0,1345,211,1,0,0,0,1346,1347,
        3,214,107,0,1347,1348,5,127,0,0,1348,1350,1,0,0,0,1349,1346,1,0,
        0,0,1349,1350,1,0,0,0,1350,1351,1,0,0,0,1351,1353,5,132,0,0,1352,
        1354,3,216,108,0,1353,1352,1,0,0,0,1353,1354,1,0,0,0,1354,213,1,
        0,0,0,1355,1356,5,132,0,0,1356,215,1,0,0,0,1357,1359,5,85,0,0,1358,
        1360,3,218,109,0,1359,1358,1,0,0,0,1359,1360,1,0,0,0,1360,1361,1,
        0,0,0,1361,1362,5,86,0,0,1362,217,1,0,0,0,1363,1365,3,220,110,0,
        1364,1363,1,0,0,0,1365,1366,1,0,0,0,1366,1364,1,0,0,0,1366,1367,
        1,0,0,0,1367,219,1,0,0,0,1368,1369,5,85,0,0,1369,1370,3,218,109,
        0,1370,1371,5,86,0,0,1371,1386,1,0,0,0,1372,1373,5,87,0,0,1373,1374,
        3,218,109,0,1374,1375,5,88,0,0,1375,1386,1,0,0,0,1376,1377,5,89,
        0,0,1377,1378,3,218,109,0,1378,1379,5,90,0,0,1379,1386,1,0,0,0,1380,
        1382,8,16,0,0,1381,1380,1,0,0,0,1382,1383,1,0,0,0,1383,1381,1,0,
        0,0,1383,1384,1,0,0,0,1384,1386,1,0,0,0,1385,1368,1,0,0,0,1385,1372,
        1,0,0,0,1385,1376,1,0,0,0,1385,1381,1,0,0,0,1386,221,1,0,0,0,1387,
        1392,3,224,112,0,1388,1389,5,122,0,0,1389,1391,3,224,112,0,1390,
        1388,1,0,0,0,1391,1394,1,0,0,0,1392,1390,1,0,0,0,1392,1393,1,0,0,
        0,1393,223,1,0,0,0,1394,1392,1,0,0,0,1395,1397,3,226,113,0,1396,
        1398,3,268,134,0,1397,1396,1,0,0,0,1397,1398,1,0,0,0,1398,225,1,
        0,0,0,1399,1405,3,228,114,0,1400,1401,3,230,115,0,1401,1402,3,232,
        116,0,1402,1403,3,234,117,0,1403,1405,1,0,0,0,1404,1399,1,0,0,0,
        1404,1400,1,0,0,0,1405,227,1,0,0,0,1406,1408,3,236,118,0,1407,1409,
        5,22,0,0,1408,1407,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0,0,0,1410,
        1406,1,0,0,0,1411,1414,1,0,0,0,1412,1410,1,0,0,0,1412,1413,1,0,0,
        0,1413,1415,1,0,0,0,1414,1412,1,0,0,0,1415,1416,3,230,115,0,1416,
        229,1,0,0,0,1417,1418,6,115,-1,0,1418,1420,3,244,122,0,1419,1421,
        3,204,102,0,1420,1419,1,0,0,0,1420,1421,1,0,0,0,1421,1427,1,0,0,
        0,1422,1423,5,85,0,0,1423,1424,3,228,114,0,1424,1425,5,86,0,0,1425,
        1427,1,0,0,0,1426,1417,1,0,0,0,1426,1422,1,0,0,0,1427,1442,1,0,0,
        0,1428,1438,10,2,0,0,1429,1439,3,232,116,0,1430,1432,5,87,0,0,1431,
        1433,3,92,46,0,1432,1431,1,0,0,0,1432,1433,1,0,0,0,1433,1434,1,0,
        0,0,1434,1436,5,88,0,0,1435,1437,3,204,102,0,1436,1435,1,0,0,0,1436,
        1437,1,0,0,0,1437,1439,1,0,0,0,1438,1429,1,0,0,0,1438,1430,1,0,0,
        0,1439,1441,1,0,0,0,1440,1428,1,0,0,0,1441,1444,1,0,0,0,1442,1440,
        1,0,0,0,1442,1443,1,0,0,0,1443,231,1,0,0,0,1444,1442,1,0,0,0,1445,
        1447,5,85,0,0,1446,1448,3,258,129,0,1447,1446,1,0,0,0,1447,1448,
        1,0,0,0,1448,1449,1,0,0,0,1449,1451,5,86,0,0,1450,1452,3,238,119,
        0,1451,1450,1,0,0,0,1451,1452,1,0,0,0,1452,1454,1,0,0,0,1453,1455,
        3,242,121,0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,1457,1,0,0,
        0,1456,1458,3,370,185,0,1457,1456,1,0,0,0,1457,1458,1,0,0,0,1458,
        1460,1,0,0,0,1459,1461,3,204,102,0,1460,1459,1,0,0,0,1460,1461,1,
        0,0,0,1461,233,1,0,0,0,1462,1463,5,124,0,0,1463,1465,3,152,76,0,
        1464,1466,3,248,124,0,1465,1464,1,0,0,0,1465,1466,1,0,0,0,1466,235,
        1,0,0,0,1467,1469,7,17,0,0,1468,1470,3,204,102,0,1469,1468,1,0,0,
        0,1469,1470,1,0,0,0,1470,1482,1,0,0,0,1471,1473,3,10,5,0,1472,1471,
        1,0,0,0,1472,1473,1,0,0,0,1473,1474,1,0,0,0,1474,1476,5,93,0,0,1475,
        1477,3,204,102,0,1476,1475,1,0,0,0,1476,1477,1,0,0,0,1477,1479,1,
        0,0,0,1478,1480,3,238,119,0,1479,1478,1,0,0,0,1479,1480,1,0,0,0,
        1480,1482,1,0,0,0,1481,1467,1,0,0,0,1481,1472,1,0,0,0,1482,237,1,
        0,0,0,1483,1485,3,240,120,0,1484,1483,1,0,0,0,1485,1486,1,0,0,0,
        1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487,239,1,0,0,0,1488,1489,7,
        18,0,0,1489,241,1,0,0,0,1490,1491,7,17,0,0,1491,243,1,0,0,0,1492,
        1494,5,131,0,0,1493,1492,1,0,0,0,1493,1494,1,0,0,0,1494,1495,1,0,
        0,0,1495,1496,3,4,2,0,1496,245,1,0,0,0,1497,1499,3,150,75,0,1498,
        1500,3,248,124,0,1499,1498,1,0,0,0,1499,1500,1,0,0,0,1500,247,1,
        0,0,0,1501,1510,3,250,125,0,1502,1504,3,252,126,0,1503,1502,1,0,
        0,0,1503,1504,1,0,0,0,1504,1505,1,0,0,0,1505,1506,3,232,116,0,1506,
        1507,3,234,117,0,1507,1510,1,0,0,0,1508,1510,3,254,127,0,1509,1501,
        1,0,0,0,1509,1503,1,0,0,0,1509,1508,1,0,0,0,1510,249,1,0,0,0,1511,
        1521,3,252,126,0,1512,1514,3,236,118,0,1513,1512,1,0,0,0,1514,1515,
        1,0,0,0,1515,1513,1,0,0,0,1515,1516,1,0,0,0,1516,1518,1,0,0,0,1517,
        1519,3,252,126,0,1518,1517,1,0,0,0,1518,1519,1,0,0,0,1519,1521,1,
        0,0,0,1520,1511,1,0,0,0,1520,1513,1,0,0,0,1521,251,1,0,0,0,1522,
        1523,6,126,-1,0,1523,1537,3,232,116,0,1524,1526,5,87,0,0,1525,1527,
        3,92,46,0,1526,1525,1,0,0,0,1526,1527,1,0,0,0,1527,1528,1,0,0,0,
        1528,1530,5,88,0,0,1529,1531,3,204,102,0,1530,1529,1,0,0,0,1530,
        1531,1,0,0,0,1531,1537,1,0,0,0,1532,1533,5,85,0,0,1533,1534,3,250,
        125,0,1534,1535,5,86,0,0,1535,1537,1,0,0,0,1536,1522,1,0,0,0,1536,
        1524,1,0,0,0,1536,1532,1,0,0,0,1537,1553,1,0,0,0,1538,1549,10,4,
        0,0,1539,1550,3,232,116,0,1540,1541,3,252,126,0,1541,1543,5,87,0,
        0,1542,1544,3,92,46,0,1543,1542,1,0,0,0,1543,1544,1,0,0,0,1544,1545,
        1,0,0,0,1545,1547,5,88,0,0,1546,1548,3,204,102,0,1547,1546,1,0,0,
        0,1547,1548,1,0,0,0,1548,1550,1,0,0,0,1549,1539,1,0,0,0,1549,1540,
        1,0,0,0,1550,1552,1,0,0,0,1551,1538,1,0,0,0,1552,1555,1,0,0,0,1553,
        1551,1,0,0,0,1553,1554,1,0,0,0,1554,253,1,0,0,0,1555,1553,1,0,0,
        0,1556,1558,3,236,118,0,1557,1556,1,0,0,0,1558,1561,1,0,0,0,1559,
        1557,1,0,0,0,1559,1560,1,0,0,0,1560,1562,1,0,0,0,1561,1559,1,0,0,
        0,1562,1563,3,256,128,0,1563,255,1,0,0,0,1564,1565,6,128,-1,0,1565,
        1566,5,131,0,0,1566,1581,1,0,0,0,1567,1577,10,2,0,0,1568,1578,3,
        232,116,0,1569,1571,5,87,0,0,1570,1572,3,92,46,0,1571,1570,1,0,0,
        0,1571,1572,1,0,0,0,1572,1573,1,0,0,0,1573,1575,5,88,0,0,1574,1576,
        3,204,102,0,1575,1574,1,0,0,0,1575,1576,1,0,0,0,1576,1578,1,0,0,
        0,1577,1568,1,0,0,0,1577,1569,1,0,0,0,1578,1580,1,0,0,0,1579,1567,
        1,0,0,0,1580,1583,1,0,0,0,1581,1579,1,0,0,0,1581,1582,1,0,0,0,1582,
        257,1,0,0,0,1583,1581,1,0,0,0,1584,1589,3,260,130,0,1585,1587,5,
        122,0,0,1586,1585,1,0,0,0,1586,1587,1,0,0,0,1587,1588,1,0,0,0,1588,
        1590,5,131,0,0,1589,1586,1,0,0,0,1589,1590,1,0,0,0,1590,259,1,0,
        0,0,1591,1596,3,262,131,0,1592,1593,5,122,0,0,1593,1595,3,262,131,
        0,1594,1592,1,0,0,0,1595,1598,1,0,0,0,1596,1594,1,0,0,0,1596,1597,
        1,0,0,0,1597,261,1,0,0,0,1598,1596,1,0,0,0,1599,1601,3,204,102,0,
        1600,1599,1,0,0,0,1600,1601,1,0,0,0,1601,1602,1,0,0,0,1602,1607,
        3,138,69,0,1603,1608,3,226,113,0,1604,1606,3,248,124,0,1605,1604,
        1,0,0,0,1605,1606,1,0,0,0,1606,1608,1,0,0,0,1607,1603,1,0,0,0,1607,
        1605,1,0,0,0,1608,1611,1,0,0,0,1609,1610,5,101,0,0,1610,1612,3,272,
        136,0,1611,1609,1,0,0,0,1611,1612,1,0,0,0,1612,263,1,0,0,0,1613,
        1615,3,204,102,0,1614,1613,1,0,0,0,1614,1615,1,0,0,0,1615,1617,1,
        0,0,0,1616,1618,3,138,69,0,1617,1616,1,0,0,0,1617,1618,1,0,0,0,1618,
        1619,1,0,0,0,1619,1621,3,226,113,0,1620,1622,3,298,149,0,1621,1620,
        1,0,0,0,1621,1622,1,0,0,0,1622,1623,1,0,0,0,1623,1624,3,266,133,
        0,1624,265,1,0,0,0,1625,1627,3,322,161,0,1626,1625,1,0,0,0,1626,
        1627,1,0,0,0,1627,1628,1,0,0,0,1628,1634,3,100,50,0,1629,1634,3,
        360,180,0,1630,1631,5,101,0,0,1631,1632,7,19,0,0,1632,1634,5,128,
        0,0,1633,1626,1,0,0,0,1633,1629,1,0,0,0,1633,1630,1,0,0,0,1634,267,
        1,0,0,0,1635,1641,3,270,135,0,1636,1637,5,85,0,0,1637,1638,3,34,
        17,0,1638,1639,5,86,0,0,1639,1641,1,0,0,0,1640,1635,1,0,0,0,1640,
        1636,1,0,0,0,1641,269,1,0,0,0,1642,1643,5,101,0,0,1643,1646,3,272,
        136,0,1644,1646,3,276,138,0,1645,1642,1,0,0,0,1645,1644,1,0,0,0,
        1646,271,1,0,0,0,1647,1650,3,86,43,0,1648,1650,3,276,138,0,1649,
        1647,1,0,0,0,1649,1648,1,0,0,0,1650,273,1,0,0,0,1651,1653,3,272,
        136,0,1652,1654,5,131,0,0,1653,1652,1,0,0,0,1653,1654,1,0,0,0,1654,
        1662,1,0,0,0,1655,1656,5,122,0,0,1656,1658,3,272,136,0,1657,1659,
        5,131,0,0,1658,1657,1,0,0,0,1658,1659,1,0,0,0,1659,1661,1,0,0,0,
        1660,1655,1,0,0,0,1661,1664,1,0,0,0,1662,1660,1,0,0,0,1662,1663,
        1,0,0,0,1663,275,1,0,0,0,1664,1662,1,0,0,0,1665,1670,5,89,0,0,1666,
        1668,3,274,137,0,1667,1669,5,122,0,0,1668,1667,1,0,0,0,1668,1669,
        1,0,0,0,1669,1671,1,0,0,0,1670,1666,1,0,0,0,1670,1671,1,0,0,0,1671,
        1672,1,0,0,0,1672,1673,5,90,0,0,1673,277,1,0,0,0,1674,1677,5,132,
        0,0,1675,1677,3,342,171,0,1676,1674,1,0,0,0,1676,1675,1,0,0,0,1677,
        279,1,0,0,0,1678,1679,3,282,141,0,1679,1681,5,89,0,0,1680,1682,3,
        290,145,0,1681,1680,1,0,0,0,1681,1682,1,0,0,0,1682,1683,1,0,0,0,
        1683,1684,5,90,0,0,1684,281,1,0,0,0,1685,1687,3,288,144,0,1686,1688,
        3,204,102,0,1687,1686,1,0,0,0,1687,1688,1,0,0,0,1688,1693,1,0,0,
        0,1689,1691,3,284,142,0,1690,1692,3,286,143,0,1691,1690,1,0,0,0,
        1691,1692,1,0,0,0,1692,1694,1,0,0,0,1693,1689,1,0,0,0,1693,1694,
        1,0,0,0,1694,1696,1,0,0,0,1695,1697,3,304,152,0,1696,1695,1,0,0,
        0,1696,1697,1,0,0,0,1697,1709,1,0,0,0,1698,1700,5,77,0,0,1699,1701,
        3,204,102,0,1700,1699,1,0,0,0,1700,1701,1,0,0,0,1701,1706,1,0,0,
        0,1702,1704,3,284,142,0,1703,1705,3,286,143,0,1704,1703,1,0,0,0,
        1704,1705,1,0,0,0,1705,1707,1,0,0,0,1706,1702,1,0,0,0,1706,1707,
        1,0,0,0,1707,1709,1,0,0,0,1708,1685,1,0,0,0,1708,1698,1,0,0,0,1709,
        283,1,0,0,0,1710,1712,3,10,5,0,1711,1710,1,0,0,0,1711,1712,1,0,0,
        0,1712,1713,1,0,0,0,1713,1714,3,278,139,0,1714,285,1,0,0,0,1715,
        1716,5,38,0,0,1716,287,1,0,0,0,1717,1718,7,15,0,0,1718,289,1,0,0,
        0,1719,1724,3,292,146,0,1720,1721,3,314,157,0,1721,1722,5,126,0,
        0,1722,1724,1,0,0,0,1723,1719,1,0,0,0,1723,1720,1,0,0,0,1724,1725,
        1,0,0,0,1725,1723,1,0,0,0,1725,1726,1,0,0,0,1726,291,1,0,0,0,1727,
        1729,3,204,102,0,1728,1727,1,0,0,0,1728,1729,1,0,0,0,1729,1731,1,
        0,0,0,1730,1732,3,138,69,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,
        1734,1,0,0,0,1733,1735,3,294,147,0,1734,1733,1,0,0,0,1734,1735,1,
        0,0,0,1735,1736,1,0,0,0,1736,1744,5,128,0,0,1737,1744,3,264,132,
        0,1738,1744,3,196,98,0,1739,1744,3,130,65,0,1740,1744,3,334,167,
        0,1741,1744,3,126,63,0,1742,1744,3,132,66,0,1743,1728,1,0,0,0,1743,
        1737,1,0,0,0,1743,1738,1,0,0,0,1743,1739,1,0,0,0,1743,1740,1,0,0,
        0,1743,1741,1,0,0,0,1743,1742,1,0,0,0,1744,293,1,0,0,0,1745,1750,
        3,296,148,0,1746,1747,5,122,0,0,1747,1749,3,296,148,0,1748,1746,
        1,0,0,0,1749,1752,1,0,0,0,1750,1748,1,0,0,0,1750,1751,1,0,0,0,1751,
        295,1,0,0,0,1752,1750,1,0,0,0,1753,1763,3,226,113,0,1754,1756,3,
        298,149,0,1755,1754,1,0,0,0,1755,1756,1,0,0,0,1756,1758,1,0,0,0,
        1757,1759,3,302,151,0,1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759,1764,
        1,0,0,0,1760,1762,3,270,135,0,1761,1760,1,0,0,0,1761,1762,1,0,0,
        0,1762,1764,1,0,0,0,1763,1755,1,0,0,0,1763,1761,1,0,0,0,1764,1774,
        1,0,0,0,1765,1767,5,132,0,0,1766,1765,1,0,0,0,1766,1767,1,0,0,0,
        1767,1769,1,0,0,0,1768,1770,3,204,102,0,1769,1768,1,0,0,0,1769,1770,
        1,0,0,0,1770,1771,1,0,0,0,1771,1772,5,126,0,0,1772,1774,3,92,46,
        0,1773,1753,1,0,0,0,1773,1766,1,0,0,0,1774,297,1,0,0,0,1775,1777,
        3,300,150,0,1776,1775,1,0,0,0,1777,1778,1,0,0,0,1778,1776,1,0,0,
        0,1778,1779,1,0,0,0,1779,299,1,0,0,0,1780,1781,7,20,0,0,1781,301,
        1,0,0,0,1782,1783,5,101,0,0,1783,1784,5,134,0,0,1784,1785,6,151,
        -1,0,1785,303,1,0,0,0,1786,1787,5,126,0,0,1787,1788,3,306,153,0,
        1788,305,1,0,0,0,1789,1791,3,308,154,0,1790,1792,5,131,0,0,1791,
        1790,1,0,0,0,1791,1792,1,0,0,0,1792,1800,1,0,0,0,1793,1794,5,122,
        0,0,1794,1796,3,308,154,0,1795,1797,5,131,0,0,1796,1795,1,0,0,0,
        1796,1797,1,0,0,0,1797,1799,1,0,0,0,1798,1793,1,0,0,0,1799,1802,
        1,0,0,0,1800,1798,1,0,0,0,1800,1801,1,0,0,0,1801,307,1,0,0,0,1802,
        1800,1,0,0,0,1803,1805,3,204,102,0,1804,1803,1,0,0,0,1804,1805,1,
        0,0,0,1805,1818,1,0,0,0,1806,1819,3,312,156,0,1807,1809,5,80,0,0,
        1808,1810,3,314,157,0,1809,1808,1,0,0,0,1809,1810,1,0,0,0,1810,1811,
        1,0,0,0,1811,1819,3,312,156,0,1812,1814,3,314,157,0,1813,1815,5,
        80,0,0,1814,1813,1,0,0,0,1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,
        1817,3,312,156,0,1817,1819,1,0,0,0,1818,1806,1,0,0,0,1818,1807,1,
        0,0,0,1818,1812,1,0,0,0,1819,309,1,0,0,0,1820,1822,3,10,5,0,1821,
        1820,1,0,0,0,1821,1822,1,0,0,0,1822,1823,1,0,0,0,1823,1826,3,278,
        139,0,1824,1826,3,162,81,0,1825,1821,1,0,0,0,1825,1824,1,0,0,0,1826,
        311,1,0,0,0,1827,1828,3,310,155,0,1828,313,1,0,0,0,1829,1830,7,21,
        0,0,1830,315,1,0,0,0,1831,1832,5,52,0,0,1832,1833,3,318,159,0,1833,
        317,1,0,0,0,1834,1836,3,150,75,0,1835,1837,3,320,160,0,1836,1835,
        1,0,0,0,1836,1837,1,0,0,0,1837,319,1,0,0,0,1838,1840,3,236,118,0,
        1839,1841,3,320,160,0,1840,1839,1,0,0,0,1840,1841,1,0,0,0,1841,321,
        1,0,0,0,1842,1843,5,126,0,0,1843,1844,3,324,162,0,1844,323,1,0,0,
        0,1845,1847,3,326,163,0,1846,1848,5,131,0,0,1847,1846,1,0,0,0,1847,
        1848,1,0,0,0,1848,1856,1,0,0,0,1849,1850,5,122,0,0,1850,1852,3,326,
        163,0,1851,1853,5,131,0,0,1852,1851,1,0,0,0,1852,1853,1,0,0,0,1853,
        1855,1,0,0,0,1854,1849,1,0,0,0,1855,1858,1,0,0,0,1856,1854,1,0,0,
        0,1856,1857,1,0,0,0,1857,325,1,0,0,0,1858,1856,1,0,0,0,1859,1866,
        3,328,164,0,1860,1862,5,85,0,0,1861,1863,3,34,17,0,1862,1861,1,0,
        0,0,1862,1863,1,0,0,0,1863,1864,1,0,0,0,1864,1867,5,86,0,0,1865,
        1867,3,276,138,0,1866,1860,1,0,0,0,1866,1865,1,0,0,0,1867,327,1,
        0,0,0,1868,1871,3,310,155,0,1869,1871,5,132,0,0,1870,1868,1,0,0,
        0,1870,1869,1,0,0,0,1871,329,1,0,0,0,1872,1873,5,52,0,0,1873,1874,
        3,378,189,0,1874,331,1,0,0,0,1875,1879,5,52,0,0,1876,1877,5,4,0,
        0,1877,1880,5,132,0,0,1878,1880,5,140,0,0,1879,1876,1,0,0,0,1879,
        1878,1,0,0,0,1880,333,1,0,0,0,1881,1882,5,68,0,0,1882,1883,5,102,
        0,0,1883,1884,3,336,168,0,1884,1885,5,103,0,0,1885,1886,3,122,61,
        0,1886,335,1,0,0,0,1887,1892,3,338,169,0,1888,1889,5,122,0,0,1889,
        1891,3,338,169,0,1890,1888,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,
        0,0,0,1892,1893,1,0,0,0,1893,337,1,0,0,0,1894,1892,1,0,0,0,1895,
        1898,3,340,170,0,1896,1898,3,262,131,0,1897,1895,1,0,0,0,1897,1896,
        1,0,0,0,1898,339,1,0,0,0,1899,1900,5,68,0,0,1900,1901,5,102,0,0,
        1901,1902,3,336,168,0,1902,1903,5,103,0,0,1903,1905,1,0,0,0,1904,
        1899,1,0,0,0,1904,1905,1,0,0,0,1905,1906,1,0,0,0,1906,1909,5,21,
        0,0,1907,1909,5,76,0,0,1908,1904,1,0,0,0,1908,1907,1,0,0,0,1909,
        1921,1,0,0,0,1910,1912,5,131,0,0,1911,1910,1,0,0,0,1911,1912,1,0,
        0,0,1912,1914,1,0,0,0,1913,1915,5,132,0,0,1914,1913,1,0,0,0,1914,
        1915,1,0,0,0,1915,1922,1,0,0,0,1916,1918,5,132,0,0,1917,1916,1,0,
        0,0,1917,1918,1,0,0,0,1918,1919,1,0,0,0,1919,1920,5,101,0,0,1920,
        1922,3,246,123,0,1921,1911,1,0,0,0,1921,1917,1,0,0,0,1922,341,1,
        0,0,0,1923,1924,3,346,173,0,1924,1926,5,102,0,0,1925,1927,3,348,
        174,0,1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1928,1,0,0,0,1928,
        1929,5,103,0,0,1929,343,1,0,0,0,1930,1942,3,342,171,0,1931,1934,
        3,330,165,0,1932,1934,3,332,166,0,1933,1931,1,0,0,0,1933,1932,1,
        0,0,0,1934,1935,1,0,0,0,1935,1937,5,102,0,0,1936,1938,3,348,174,
        0,1937,1936,1,0,0,0,1937,1938,1,0,0,0,1938,1939,1,0,0,0,1939,1940,
        5,103,0,0,1940,1942,1,0,0,0,1941,1930,1,0,0,0,1941,1933,1,0,0,0,
        1942,345,1,0,0,0,1943,1944,5,132,0,0,1944,347,1,0,0,0,1945,1947,
        3,350,175,0,1946,1948,5,131,0,0,1947,1946,1,0,0,0,1947,1948,1,0,
        0,0,1948,1956,1,0,0,0,1949,1950,5,122,0,0,1950,1952,3,350,175,0,
        1951,1953,5,131,0,0,1952,1951,1,0,0,0,1952,1953,1,0,0,0,1953,1955,
        1,0,0,0,1954,1949,1,0,0,0,1955,1958,1,0,0,0,1956,1954,1,0,0,0,1956,
        1957,1,0,0,0,1957,349,1,0,0,0,1958,1956,1,0,0,0,1959,1963,3,246,
        123,0,1960,1963,3,92,46,0,1961,1963,3,4,2,0,1962,1959,1,0,0,0,1962,
        1960,1,0,0,0,1962,1961,1,0,0,0,1963,351,1,0,0,0,1964,1965,5,76,0,
        0,1965,1971,3,10,5,0,1966,1972,5,132,0,0,1967,1969,5,68,0,0,1968,
        1967,1,0,0,0,1968,1969,1,0,0,0,1969,1970,1,0,0,0,1970,1972,3,342,
        171,0,1971,1966,1,0,0,0,1971,1968,1,0,0,0,1972,353,1,0,0,0,1973,
        1975,5,36,0,0,1974,1973,1,0,0,0,1974,1975,1,0,0,0,1975,1976,1,0,
        0,0,1976,1977,5,68,0,0,1977,1978,3,122,61,0,1978,355,1,0,0,0,1979,
        1980,5,68,0,0,1980,1981,5,102,0,0,1981,1982,5,103,0,0,1982,1983,
        3,122,61,0,1983,357,1,0,0,0,1984,1985,5,73,0,0,1985,1986,3,100,50,
        0,1986,1987,3,362,181,0,1987,359,1,0,0,0,1988,1990,5,73,0,0,1989,
        1991,3,322,161,0,1990,1989,1,0,0,0,1990,1991,1,0,0,0,1991,1992,1,
        0,0,0,1992,1993,3,100,50,0,1993,1994,3,362,181,0,1994,361,1,0,0,
        0,1995,1997,3,364,182,0,1996,1995,1,0,0,0,1997,1998,1,0,0,0,1998,
        1996,1,0,0,0,1998,1999,1,0,0,0,1999,363,1,0,0,0,2000,2001,5,17,0,
        0,2001,2002,5,85,0,0,2002,2003,3,366,183,0,2003,2004,5,86,0,0,2004,
        2005,3,100,50,0,2005,365,1,0,0,0,2006,2008,3,204,102,0,2007,2006,
        1,0,0,0,2007,2008,1,0,0,0,2008,2009,1,0,0,0,2009,2012,3,150,75,0,
        2010,2013,3,226,113,0,2011,2013,3,248,124,0,2012,2010,1,0,0,0,2012,
        2011,1,0,0,0,2012,2013,1,0,0,0,2013,2016,1,0,0,0,2014,2016,5,131,
        0,0,2015,2007,1,0,0,0,2015,2014,1,0,0,0,2016,367,1,0,0,0,2017,2019,
        5,71,0,0,2018,2020,3,86,43,0,2019,2018,1,0,0,0,2019,2020,1,0,0,0,
        2020,369,1,0,0,0,2021,2024,3,372,186,0,2022,2024,3,376,188,0,2023,
        2021,1,0,0,0,2023,2022,1,0,0,0,2024,371,1,0,0,0,2025,2026,5,71,0,
        0,2026,2028,5,85,0,0,2027,2029,3,374,187,0,2028,2027,1,0,0,0,2028,
        2029,1,0,0,0,2029,2030,1,0,0,0,2030,2031,5,86,0,0,2031,373,1,0,0,
        0,2032,2034,3,246,123,0,2033,2035,5,131,0,0,2034,2033,1,0,0,0,2034,
        2035,1,0,0,0,2035,2043,1,0,0,0,2036,2037,5,122,0,0,2037,2039,3,246,
        123,0,2038,2040,5,131,0,0,2039,2038,1,0,0,0,2039,2040,1,0,0,0,2040,
        2042,1,0,0,0,2041,2036,1,0,0,0,2042,2045,1,0,0,0,2043,2041,1,0,0,
        0,2043,2044,1,0,0,0,2044,375,1,0,0,0,2045,2043,1,0,0,0,2046,2047,
        5,50,0,0,2047,2048,5,85,0,0,2048,2049,3,92,46,0,2049,2050,5,86,0,
        0,2050,2053,1,0,0,0,2051,2053,5,50,0,0,2052,2046,1,0,0,0,2052,2051,
        1,0,0,0,2053,377,1,0,0,0,2054,2057,5,49,0,0,2055,2056,5,87,0,0,2056,
        2058,5,88,0,0,2057,2055,1,0,0,0,2057,2058,1,0,0,0,2058,2106,1,0,
        0,0,2059,2062,5,28,0,0,2060,2061,5,87,0,0,2061,2063,5,88,0,0,2062,
        2060,1,0,0,0,2062,2063,1,0,0,0,2063,2106,1,0,0,0,2064,2106,5,91,
        0,0,2065,2106,5,92,0,0,2066,2106,5,93,0,0,2067,2106,5,94,0,0,2068,
        2106,5,95,0,0,2069,2106,5,96,0,0,2070,2106,5,97,0,0,2071,2106,5,
        98,0,0,2072,2106,5,99,0,0,2073,2106,5,100,0,0,2074,2106,5,101,0,
        0,2075,2106,5,103,0,0,2076,2106,5,102,0,0,2077,2106,5,117,0,0,2078,
        2106,5,104,0,0,2079,2106,5,105,0,0,2080,2106,5,106,0,0,2081,2106,
        5,108,0,0,2082,2106,5,109,0,0,2083,2106,5,110,0,0,2084,2106,5,111,
        0,0,2085,2086,5,102,0,0,2086,2106,5,102,0,0,2087,2088,5,103,0,0,
        2088,2106,5,103,0,0,2089,2106,5,113,0,0,2090,2106,5,112,0,0,2091,
        2106,5,114,0,0,2092,2106,5,115,0,0,2093,2106,5,116,0,0,2094,2106,
        5,118,0,0,2095,2106,5,119,0,0,2096,2106,5,120,0,0,2097,2106,5,121,
        0,0,2098,2106,5,122,0,0,2099,2106,5,123,0,0,2100,2106,5,124,0,0,
        2101,2102,5,85,0,0,2102,2106,5,86,0,0,2103,2104,5,87,0,0,2104,2106,
        5,88,0,0,2105,2054,1,0,0,0,2105,2059,1,0,0,0,2105,2064,1,0,0,0,2105,
        2065,1,0,0,0,2105,2066,1,0,0,0,2105,2067,1,0,0,0,2105,2068,1,0,0,
        0,2105,2069,1,0,0,0,2105,2070,1,0,0,0,2105,2071,1,0,0,0,2105,2072,
        1,0,0,0,2105,2073,1,0,0,0,2105,2074,1,0,0,0,2105,2075,1,0,0,0,2105,
        2076,1,0,0,0,2105,2077,1,0,0,0,2105,2078,1,0,0,0,2105,2079,1,0,0,
        0,2105,2080,1,0,0,0,2105,2081,1,0,0,0,2105,2082,1,0,0,0,2105,2083,
        1,0,0,0,2105,2084,1,0,0,0,2105,2085,1,0,0,0,2105,2087,1,0,0,0,2105,
        2089,1,0,0,0,2105,2090,1,0,0,0,2105,2091,1,0,0,0,2105,2092,1,0,0,
        0,2105,2093,1,0,0,0,2105,2094,1,0,0,0,2105,2095,1,0,0,0,2105,2096,
        1,0,0,0,2105,2097,1,0,0,0,2105,2098,1,0,0,0,2105,2099,1,0,0,0,2105,
        2100,1,0,0,0,2105,2101,1,0,0,0,2105,2103,1,0,0,0,2106,379,1,0,0,
        0,2107,2108,7,22,0,0,2108,381,1,0,0,0,306,383,390,399,403,412,415,
        419,427,434,437,442,447,453,461,463,472,476,480,483,487,490,497,
        501,504,507,510,516,520,524,538,542,548,555,561,565,569,571,579,
        584,597,604,616,626,631,635,642,645,653,657,660,667,674,678,683,
        687,690,695,710,717,725,733,742,749,756,764,772,780,788,796,804,
        813,821,830,838,846,848,851,857,863,869,876,885,893,897,904,906,
        926,930,936,941,945,948,955,962,966,975,986,996,1001,1008,1011,1016,
        1021,1042,1047,1050,1061,1067,1072,1075,1080,1083,1090,1099,1104,
        1107,1111,1115,1119,1124,1129,1135,1141,1147,1153,1159,1162,1168,
        1172,1176,1179,1187,1189,1195,1198,1201,1204,1208,1212,1218,1228,
        1234,1240,1245,1250,1254,1267,1273,1277,1283,1288,1303,1307,1312,
        1317,1322,1328,1331,1340,1344,1349,1353,1359,1366,1383,1385,1392,
        1397,1404,1408,1412,1420,1426,1432,1436,1438,1442,1447,1451,1454,
        1457,1460,1465,1469,1472,1476,1479,1481,1486,1493,1499,1503,1509,
        1515,1518,1520,1526,1530,1536,1543,1547,1549,1553,1559,1571,1575,
        1577,1581,1586,1589,1596,1600,1605,1607,1611,1614,1617,1621,1626,
        1633,1640,1645,1649,1653,1658,1662,1668,1670,1676,1681,1687,1691,
        1693,1696,1700,1704,1706,1708,1711,1723,1725,1728,1731,1734,1743,
        1750,1755,1758,1761,1763,1766,1769,1773,1778,1791,1796,1800,1804,
        1809,1814,1818,1821,1825,1836,1840,1847,1852,1856,1862,1866,1870,
        1879,1892,1897,1904,1908,1911,1914,1917,1921,1926,1933,1937,1941,
        1947,1952,1956,1962,1968,1971,1974,1990,1998,2007,2012,2015,2019,
        2023,2028,2034,2039,2043,2052,2057,2062,2105
    ]

class CPP14Parser ( Parser ):

    grammarFileName = "CPP14Parser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'alignas'", "'alignof'", 
                     "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", 
                     "'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", 
                     "'constexpr'", "'const_cast'", "'continue'", "'decltype'", 
                     "'default'", "'delete'", "'do'", "'double'", "'dynamic_cast'", 
                     "'else'", "'enum'", "'explicit'", "'export'", "'extern'", 
                     "'false'", "'final'", "'float'", "'for'", "'friend'", 
                     "'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", 
                     "'namespace'", "'new'", "'noexcept'", "'nullptr'", 
                     "'operator'", "'override'", "'private'", "'protected'", 
                     "'public'", "'register'", "'reinterpret_cast'", "'return'", 
                     "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", 
                     "'static_cast'", "'struct'", "'switch'", "'template'", 
                     "'this'", "'thread_local'", "'throw'", "'true'", "'try'", 
                     "'typedef'", "'typeid'", "'typename'", "'union'", "'unsigned'", 
                     "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", 
                     "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", 
                     "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", 
                     "'~'", "<INVALID>", "'='", "'<'", "'>'", "'+='", "'-='", 
                     "'*='", "'/='", "'%='", "'^='", "'&='", "'|='", "'<<='", 
                     "'>>='", "'=='", "'!='", "'<='", "'>='", "<INVALID>", 
                     "<INVALID>", "'++'", "'--'", "','", "'->*'", "'->'", 
                     "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'" ]

    symbolicNames = [ "<INVALID>", "IntegerLiteral", "CharacterLiteral", 
                      "FloatingLiteral", "StringLiteral", "BooleanLiteral", 
                      "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", 
                      "Directive", "Alignas", "Alignof", "Asm", "Auto", 
                      "Bool", "Break", "Case", "Catch", "Char", "Char16", 
                      "Char32", "Class", "Const", "Constexpr", "Const_cast", 
                      "Continue", "Decltype", "Default", "Delete", "Do", 
                      "Double", "Dynamic_cast", "Else", "Enum", "Explicit", 
                      "Export", "Extern", "False_", "Final", "Float", "For", 
                      "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", 
                      "Namespace", "New", "Noexcept", "Nullptr", "Operator", 
                      "Override", "Private", "Protected", "Public", "Register", 
                      "Reinterpret_cast", "Return", "Short", "Signed", "Sizeof", 
                      "Static", "Static_assert", "Static_cast", "Struct", 
                      "Switch", "Template", "This", "Thread_local", "Throw", 
                      "True_", "Try", "Typedef", "Typeid_", "Typename_", 
                      "Union", "Unsigned", "Using", "Virtual", "Void", "Volatile", 
                      "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", 
                      "RightBracket", "LeftBrace", "RightBrace", "Plus", 
                      "Minus", "Star", "Div", "Mod", "Caret", "And", "Or", 
                      "Tilde", "Not", "Assign", "Less", "Greater", "PlusAssign", 
                      "MinusAssign", "StarAssign", "DivAssign", "ModAssign", 
                      "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", 
                      "RightShiftAssign", "Equal", "NotEqual", "LessEqual", 
                      "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", 
                      "Comma", "ArrowStar", "Arrow", "Question", "Colon", 
                      "Doublecolon", "Semi", "Dot", "DotStar", "Ellipsis", 
                      "Identifier", "DecimalLiteral", "OctalLiteral", "HexadecimalLiteral", 
                      "BinaryLiteral", "Integersuffix", "UserDefinedIntegerLiteral", 
                      "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", 
                      "UserDefinedCharacterLiteral", "Whitespace", "Newline", 
                      "BlockComment", "LineComment", "ENTER" ]

    RULE_translationUnit = 0
    RULE_primaryExpression = 1
    RULE_idExpression = 2
    RULE_unqualifiedId = 3
    RULE_qualifiedId = 4
    RULE_nestedNameSpecifier = 5
    RULE_lambdaExpression = 6
    RULE_lambdaIntroducer = 7
    RULE_lambdaCapture = 8
    RULE_captureDefault = 9
    RULE_captureList = 10
    RULE_capture = 11
    RULE_simpleCapture = 12
    RULE_initcapture = 13
    RULE_lambdaDeclarator = 14
    RULE_postfixExpression = 15
    RULE_typeIdOfTheTypeId = 16
    RULE_expressionList = 17
    RULE_pseudoDestructorName = 18
    RULE_unaryExpression = 19
    RULE_unaryOperator = 20
    RULE_newExpression = 21
    RULE_newPlacement = 22
    RULE_newTypeId = 23
    RULE_newDeclarator = 24
    RULE_noPointerNewDeclarator = 25
    RULE_newInitializer = 26
    RULE_deleteExpression = 27
    RULE_noExceptExpression = 28
    RULE_castExpression = 29
    RULE_pointerMemberExpression = 30
    RULE_multiplicativeExpression = 31
    RULE_additiveExpression = 32
    RULE_shiftExpression = 33
    RULE_shiftOperator = 34
    RULE_relationalExpression = 35
    RULE_equalityExpression = 36
    RULE_andExpression = 37
    RULE_exclusiveOrExpression = 38
    RULE_inclusiveOrExpression = 39
    RULE_logicalAndExpression = 40
    RULE_logicalOrExpression = 41
    RULE_conditionalExpression = 42
    RULE_assignmentExpression = 43
    RULE_assignmentOperator = 44
    RULE_expression = 45
    RULE_constantExpression = 46
    RULE_statement = 47
    RULE_labeledStatement = 48
    RULE_expressionStatement = 49
    RULE_compoundStatement = 50
    RULE_statementSeq = 51
    RULE_selectionStatement = 52
    RULE_condition = 53
    RULE_iterationStatement = 54
    RULE_forInitStatement = 55
    RULE_forRangeDeclaration = 56
    RULE_forRangeInitializer = 57
    RULE_jumpStatement = 58
    RULE_declarationStatement = 59
    RULE_declarationseq = 60
    RULE_declaration = 61
    RULE_blockDeclaration = 62
    RULE_aliasDeclaration = 63
    RULE_simpleDeclaration = 64
    RULE_staticAssertDeclaration = 65
    RULE_emptyDeclaration = 66
    RULE_attributeDeclaration = 67
    RULE_declSpecifier = 68
    RULE_declSpecifierSeq = 69
    RULE_storageClassSpecifier = 70
    RULE_functionSpecifier = 71
    RULE_typedefName = 72
    RULE_typeSpecifier = 73
    RULE_trailingTypeSpecifier = 74
    RULE_typeSpecifierSeq = 75
    RULE_trailingTypeSpecifierSeq = 76
    RULE_simpleTypeLengthModifier = 77
    RULE_simpleTypeSignednessModifier = 78
    RULE_simpleTypeSpecifier = 79
    RULE_theTypeName = 80
    RULE_decltypeSpecifier = 81
    RULE_elaboratedTypeSpecifier = 82
    RULE_enumName = 83
    RULE_enumSpecifier = 84
    RULE_enumHead = 85
    RULE_opaqueEnumDeclaration = 86
    RULE_enumkey = 87
    RULE_enumbase = 88
    RULE_enumeratorList = 89
    RULE_enumeratorDefinition = 90
    RULE_enumerator = 91
    RULE_namespaceName = 92
    RULE_originalNamespaceName = 93
    RULE_namespaceDefinition = 94
    RULE_namespaceAlias = 95
    RULE_namespaceAliasDefinition = 96
    RULE_qualifiednamespacespecifier = 97
    RULE_usingDeclaration = 98
    RULE_usingDirective = 99
    RULE_asmDefinition = 100
    RULE_linkageSpecification = 101
    RULE_attributeSpecifierSeq = 102
    RULE_attributeSpecifier = 103
    RULE_alignmentspecifier = 104
    RULE_attributeList = 105
    RULE_attribute = 106
    RULE_attributeNamespace = 107
    RULE_attributeArgumentClause = 108
    RULE_balancedTokenSeq = 109
    RULE_balancedtoken = 110
    RULE_initDeclaratorList = 111
    RULE_initDeclarator = 112
    RULE_declarator = 113
    RULE_pointerDeclarator = 114
    RULE_noPointerDeclarator = 115
    RULE_parametersAndQualifiers = 116
    RULE_trailingReturnType = 117
    RULE_pointerOperator = 118
    RULE_cvqualifierseq = 119
    RULE_cvQualifier = 120
    RULE_refqualifier = 121
    RULE_declaratorid = 122
    RULE_theTypeId = 123
    RULE_abstractDeclarator = 124
    RULE_pointerAbstractDeclarator = 125
    RULE_noPointerAbstractDeclarator = 126
    RULE_abstractPackDeclarator = 127
    RULE_noPointerAbstractPackDeclarator = 128
    RULE_parameterDeclarationClause = 129
    RULE_parameterDeclarationList = 130
    RULE_parameterDeclaration = 131
    RULE_functionDefinition = 132
    RULE_functionBody = 133
    RULE_initializer = 134
    RULE_braceOrEqualInitializer = 135
    RULE_initializerClause = 136
    RULE_initializerList = 137
    RULE_bracedInitList = 138
    RULE_className = 139
    RULE_classSpecifier = 140
    RULE_classHead = 141
    RULE_classHeadName = 142
    RULE_classVirtSpecifier = 143
    RULE_classKey = 144
    RULE_memberSpecification = 145
    RULE_memberdeclaration = 146
    RULE_memberDeclaratorList = 147
    RULE_memberDeclarator = 148
    RULE_virtualSpecifierSeq = 149
    RULE_virtualSpecifier = 150
    RULE_pureSpecifier = 151
    RULE_baseClause = 152
    RULE_baseSpecifierList = 153
    RULE_baseSpecifier = 154
    RULE_classOrDeclType = 155
    RULE_baseTypeSpecifier = 156
    RULE_accessSpecifier = 157
    RULE_conversionFunctionId = 158
    RULE_conversionTypeId = 159
    RULE_conversionDeclarator = 160
    RULE_constructorInitializer = 161
    RULE_memInitializerList = 162
    RULE_memInitializer = 163
    RULE_meminitializerid = 164
    RULE_operatorFunctionId = 165
    RULE_literalOperatorId = 166
    RULE_templateDeclaration = 167
    RULE_templateparameterList = 168
    RULE_templateParameter = 169
    RULE_typeParameter = 170
    RULE_simpleTemplateId = 171
    RULE_templateId = 172
    RULE_templateName = 173
    RULE_templateArgumentList = 174
    RULE_templateArgument = 175
    RULE_typeNameSpecifier = 176
    RULE_explicitInstantiation = 177
    RULE_explicitSpecialization = 178
    RULE_tryBlock = 179
    RULE_functionTryBlock = 180
    RULE_handlerSeq = 181
    RULE_handler = 182
    RULE_exceptionDeclaration = 183
    RULE_throwExpression = 184
    RULE_exceptionSpecification = 185
    RULE_dynamicExceptionSpecification = 186
    RULE_typeIdList = 187
    RULE_noeExceptSpecification = 188
    RULE_theOperator = 189
    RULE_literal = 190

    ruleNames =  [ "translationUnit", "primaryExpression", "idExpression", 
                   "unqualifiedId", "qualifiedId", "nestedNameSpecifier", 
                   "lambdaExpression", "lambdaIntroducer", "lambdaCapture", 
                   "captureDefault", "captureList", "capture", "simpleCapture", 
                   "initcapture", "lambdaDeclarator", "postfixExpression", 
                   "typeIdOfTheTypeId", "expressionList", "pseudoDestructorName", 
                   "unaryExpression", "unaryOperator", "newExpression", 
                   "newPlacement", "newTypeId", "newDeclarator", "noPointerNewDeclarator", 
                   "newInitializer", "deleteExpression", "noExceptExpression", 
                   "castExpression", "pointerMemberExpression", "multiplicativeExpression", 
                   "additiveExpression", "shiftExpression", "shiftOperator", 
                   "relationalExpression", "equalityExpression", "andExpression", 
                   "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", 
                   "logicalOrExpression", "conditionalExpression", "assignmentExpression", 
                   "assignmentOperator", "expression", "constantExpression", 
                   "statement", "labeledStatement", "expressionStatement", 
                   "compoundStatement", "statementSeq", "selectionStatement", 
                   "condition", "iterationStatement", "forInitStatement", 
                   "forRangeDeclaration", "forRangeInitializer", "jumpStatement", 
                   "declarationStatement", "declarationseq", "declaration", 
                   "blockDeclaration", "aliasDeclaration", "simpleDeclaration", 
                   "staticAssertDeclaration", "emptyDeclaration", "attributeDeclaration", 
                   "declSpecifier", "declSpecifierSeq", "storageClassSpecifier", 
                   "functionSpecifier", "typedefName", "typeSpecifier", 
                   "trailingTypeSpecifier", "typeSpecifierSeq", "trailingTypeSpecifierSeq", 
                   "simpleTypeLengthModifier", "simpleTypeSignednessModifier", 
                   "simpleTypeSpecifier", "theTypeName", "decltypeSpecifier", 
                   "elaboratedTypeSpecifier", "enumName", "enumSpecifier", 
                   "enumHead", "opaqueEnumDeclaration", "enumkey", "enumbase", 
                   "enumeratorList", "enumeratorDefinition", "enumerator", 
                   "namespaceName", "originalNamespaceName", "namespaceDefinition", 
                   "namespaceAlias", "namespaceAliasDefinition", "qualifiednamespacespecifier", 
                   "usingDeclaration", "usingDirective", "asmDefinition", 
                   "linkageSpecification", "attributeSpecifierSeq", "attributeSpecifier", 
                   "alignmentspecifier", "attributeList", "attribute", "attributeNamespace", 
                   "attributeArgumentClause", "balancedTokenSeq", "balancedtoken", 
                   "initDeclaratorList", "initDeclarator", "declarator", 
                   "pointerDeclarator", "noPointerDeclarator", "parametersAndQualifiers", 
                   "trailingReturnType", "pointerOperator", "cvqualifierseq", 
                   "cvQualifier", "refqualifier", "declaratorid", "theTypeId", 
                   "abstractDeclarator", "pointerAbstractDeclarator", "noPointerAbstractDeclarator", 
                   "abstractPackDeclarator", "noPointerAbstractPackDeclarator", 
                   "parameterDeclarationClause", "parameterDeclarationList", 
                   "parameterDeclaration", "functionDefinition", "functionBody", 
                   "initializer", "braceOrEqualInitializer", "initializerClause", 
                   "initializerList", "bracedInitList", "className", "classSpecifier", 
                   "classHead", "classHeadName", "classVirtSpecifier", "classKey", 
                   "memberSpecification", "memberdeclaration", "memberDeclaratorList", 
                   "memberDeclarator", "virtualSpecifierSeq", "virtualSpecifier", 
                   "pureSpecifier", "baseClause", "baseSpecifierList", "baseSpecifier", 
                   "classOrDeclType", "baseTypeSpecifier", "accessSpecifier", 
                   "conversionFunctionId", "conversionTypeId", "conversionDeclarator", 
                   "constructorInitializer", "memInitializerList", "memInitializer", 
                   "meminitializerid", "operatorFunctionId", "literalOperatorId", 
                   "templateDeclaration", "templateparameterList", "templateParameter", 
                   "typeParameter", "simpleTemplateId", "templateId", "templateName", 
                   "templateArgumentList", "templateArgument", "typeNameSpecifier", 
                   "explicitInstantiation", "explicitSpecialization", "tryBlock", 
                   "functionTryBlock", "handlerSeq", "handler", "exceptionDeclaration", 
                   "throwExpression", "exceptionSpecification", "dynamicExceptionSpecification", 
                   "typeIdList", "noeExceptSpecification", "theOperator", 
                   "literal" ]

    EOF = Token.EOF
    IntegerLiteral=1
    CharacterLiteral=2
    FloatingLiteral=3
    StringLiteral=4
    BooleanLiteral=5
    PointerLiteral=6
    UserDefinedLiteral=7
    MultiLineMacro=8
    Directive=9
    Alignas=10
    Alignof=11
    Asm=12
    Auto=13
    Bool=14
    Break=15
    Case=16
    Catch=17
    Char=18
    Char16=19
    Char32=20
    Class=21
    Const=22
    Constexpr=23
    Const_cast=24
    Continue=25
    Decltype=26
    Default=27
    Delete=28
    Do=29
    Double=30
    Dynamic_cast=31
    Else=32
    Enum=33
    Explicit=34
    Export=35
    Extern=36
    False_=37
    Final=38
    Float=39
    For=40
    Friend=41
    Goto=42
    If=43
    Inline=44
    Int=45
    Long=46
    Mutable=47
    Namespace=48
    New=49
    Noexcept=50
    Nullptr=51
    Operator=52
    Override=53
    Private=54
    Protected=55
    Public=56
    Register=57
    Reinterpret_cast=58
    Return=59
    Short=60
    Signed=61
    Sizeof=62
    Static=63
    Static_assert=64
    Static_cast=65
    Struct=66
    Switch=67
    Template=68
    This=69
    Thread_local=70
    Throw=71
    True_=72
    Try=73
    Typedef=74
    Typeid_=75
    Typename_=76
    Union=77
    Unsigned=78
    Using=79
    Virtual=80
    Void=81
    Volatile=82
    Wchar=83
    While=84
    LeftParen=85
    RightParen=86
    LeftBracket=87
    RightBracket=88
    LeftBrace=89
    RightBrace=90
    Plus=91
    Minus=92
    Star=93
    Div=94
    Mod=95
    Caret=96
    And=97
    Or=98
    Tilde=99
    Not=100
    Assign=101
    Less=102
    Greater=103
    PlusAssign=104
    MinusAssign=105
    StarAssign=106
    DivAssign=107
    ModAssign=108
    XorAssign=109
    AndAssign=110
    OrAssign=111
    LeftShiftAssign=112
    RightShiftAssign=113
    Equal=114
    NotEqual=115
    LessEqual=116
    GreaterEqual=117
    AndAnd=118
    OrOr=119
    PlusPlus=120
    MinusMinus=121
    Comma=122
    ArrowStar=123
    Arrow=124
    Question=125
    Colon=126
    Doublecolon=127
    Semi=128
    Dot=129
    DotStar=130
    Ellipsis=131
    Identifier=132
    DecimalLiteral=133
    OctalLiteral=134
    HexadecimalLiteral=135
    BinaryLiteral=136
    Integersuffix=137
    UserDefinedIntegerLiteral=138
    UserDefinedFloatingLiteral=139
    UserDefinedStringLiteral=140
    UserDefinedCharacterLiteral=141
    Whitespace=142
    Newline=143
    BlockComment=144
    LineComment=145
    ENTER=146

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.11.1")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class TranslationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(CPP14Parser.EOF, 0)

        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_translationUnit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTranslationUnit" ):
                listener.enterTranslationUnit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTranslationUnit" ):
                listener.exitTranslationUnit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTranslationUnit" ):
                return visitor.visitTranslationUnit(self)
            else:
                return visitor.visitChildren(self)




    def translationUnit(self):

        localctx = CPP14Parser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543754443169808157) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 459384754220313597) != 0:
                self.state = 382
                self.declarationseq()


            self.state = 385
            self.match(CPP14Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.LiteralContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.LiteralContext,i)


        def This(self):
            return self.getToken(CPP14Parser.This, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def lambdaExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_primaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrimaryExpression" ):
                listener.enterPrimaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrimaryExpression" ):
                listener.exitPrimaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimaryExpression" ):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def primaryExpression(self):

        localctx = CPP14Parser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_primaryExpression)
        try:
            self.state = 399
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7]:
                self.enterOuterAlt(localctx, 1)
                self.state = 388 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 387
                        self.literal()

                    else:
                        raise NoViableAltException(self)
                    self.state = 390 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 2)
                self.state = 392
                self.match(CPP14Parser.This)
                pass
            elif token in [85]:
                self.enterOuterAlt(localctx, 3)
                self.state = 393
                self.match(CPP14Parser.LeftParen)
                self.state = 394
                self.expression()
                self.state = 395
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [26, 52, 99, 127, 132]:
                self.enterOuterAlt(localctx, 4)
                self.state = 397
                self.idExpression()
                pass
            elif token in [87]:
                self.enterOuterAlt(localctx, 5)
                self.state = 398
                self.lambdaExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def qualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.QualifiedIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_idExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdExpression" ):
                listener.enterIdExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdExpression" ):
                listener.exitIdExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdExpression" ):
                return visitor.visitIdExpression(self)
            else:
                return visitor.visitChildren(self)




    def idExpression(self):

        localctx = CPP14Parser.IdExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_idExpression)
        try:
            self.state = 403
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 401
                self.unqualifiedId()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 402
                self.qualifiedId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnqualifiedIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def operatorFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.OperatorFunctionIdContext,0)


        def conversionFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionFunctionIdContext,0)


        def literalOperatorId(self):
            return self.getTypedRuleContext(CPP14Parser.LiteralOperatorIdContext,0)


        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def templateId(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_unqualifiedId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnqualifiedId" ):
                listener.enterUnqualifiedId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnqualifiedId" ):
                listener.exitUnqualifiedId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnqualifiedId" ):
                return visitor.visitUnqualifiedId(self)
            else:
                return visitor.visitChildren(self)




    def unqualifiedId(self):

        localctx = CPP14Parser.UnqualifiedIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_unqualifiedId)
        try:
            self.state = 415
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 405
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 406
                self.operatorFunctionId()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 407
                self.conversionFunctionId()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 408
                self.literalOperatorId()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 409
                self.match(CPP14Parser.Tilde)
                self.state = 412
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [132]:
                    self.state = 410
                    self.className()
                    pass
                elif token in [26]:
                    self.state = 411
                    self.decltypeSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 414
                self.templateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_qualifiedId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiedId" ):
                listener.enterQualifiedId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiedId" ):
                listener.exitQualifiedId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedId" ):
                return visitor.visitQualifiedId(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedId(self):

        localctx = CPP14Parser.QualifiedIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_qualifiedId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 417
            self.nestedNameSpecifier(0)
            self.state = 419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==68:
                self.state = 418
                self.match(CPP14Parser.Template)


            self.state = 421
            self.unqualifiedId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NestedNameSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def theTypeName(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,0)


        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_nestedNameSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNestedNameSpecifier" ):
                listener.enterNestedNameSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNestedNameSpecifier" ):
                listener.exitNestedNameSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNestedNameSpecifier" ):
                return visitor.visitNestedNameSpecifier(self)
            else:
                return visitor.visitChildren(self)



    def nestedNameSpecifier(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NestedNameSpecifierContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 10
        self.enterRecursionRule(localctx, 10, self.RULE_nestedNameSpecifier, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 424
                self.theTypeName()

            elif la_ == 2:
                self.state = 425
                self.namespaceName()

            elif la_ == 3:
                self.state = 426
                self.decltypeSpecifier()


            self.state = 429
            self.match(CPP14Parser.Doublecolon)
            self._ctx.stop = self._input.LT(-1)
            self.state = 442
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NestedNameSpecifierContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_nestedNameSpecifier)
                    self.state = 431
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 437
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
                    if la_ == 1:
                        self.state = 432
                        self.match(CPP14Parser.Identifier)
                        pass

                    elif la_ == 2:
                        self.state = 434
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==68:
                            self.state = 433
                            self.match(CPP14Parser.Template)


                        self.state = 436
                        self.simpleTemplateId()
                        pass


                    self.state = 439
                    self.match(CPP14Parser.Doublecolon) 
                self.state = 444
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class LambdaExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def lambdaIntroducer(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaIntroducerContext,0)


        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def lambdaDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaExpression" ):
                listener.enterLambdaExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaExpression" ):
                listener.exitLambdaExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaExpression" ):
                return visitor.visitLambdaExpression(self)
            else:
                return visitor.visitChildren(self)




    def lambdaExpression(self):

        localctx = CPP14Parser.LambdaExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_lambdaExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            self.lambdaIntroducer()
            self.state = 447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==85:
                self.state = 446
                self.lambdaDeclarator()


            self.state = 449
            self.compoundStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaIntroducerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def lambdaCapture(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaCaptureContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaIntroducer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaIntroducer" ):
                listener.enterLambdaIntroducer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaIntroducer" ):
                listener.exitLambdaIntroducer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaIntroducer" ):
                return visitor.visitLambdaIntroducer(self)
            else:
                return visitor.visitChildren(self)




    def lambdaIntroducer(self):

        localctx = CPP14Parser.LambdaIntroducerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_lambdaIntroducer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self.match(CPP14Parser.LeftBracket)
            self.state = 453
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & -9223372032291373055) != 0:
                self.state = 452
                self.lambdaCapture()


            self.state = 455
            self.match(CPP14Parser.RightBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaCaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def captureList(self):
            return self.getTypedRuleContext(CPP14Parser.CaptureListContext,0)


        def captureDefault(self):
            return self.getTypedRuleContext(CPP14Parser.CaptureDefaultContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaCapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaCapture" ):
                listener.enterLambdaCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaCapture" ):
                listener.exitLambdaCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaCapture" ):
                return visitor.visitLambdaCapture(self)
            else:
                return visitor.visitChildren(self)




    def lambdaCapture(self):

        localctx = CPP14Parser.LambdaCaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_lambdaCapture)
        self._la = 0 # Token type
        try:
            self.state = 463
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 457
                self.captureList()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 458
                self.captureDefault()
                self.state = 461
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==122:
                    self.state = 459
                    self.match(CPP14Parser.Comma)
                    self.state = 460
                    self.captureList()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureDefaultContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_captureDefault

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaptureDefault" ):
                listener.enterCaptureDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaptureDefault" ):
                listener.exitCaptureDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCaptureDefault" ):
                return visitor.visitCaptureDefault(self)
            else:
                return visitor.visitChildren(self)




    def captureDefault(self):

        localctx = CPP14Parser.CaptureDefaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_captureDefault)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            _la = self._input.LA(1)
            if not(_la==97 or _la==101):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def capture(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CaptureContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CaptureContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_captureList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaptureList" ):
                listener.enterCaptureList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaptureList" ):
                listener.exitCaptureList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCaptureList" ):
                return visitor.visitCaptureList(self)
            else:
                return visitor.visitChildren(self)




    def captureList(self):

        localctx = CPP14Parser.CaptureListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_captureList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            self.capture()
            self.state = 472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 468
                self.match(CPP14Parser.Comma)
                self.state = 469
                self.capture()
                self.state = 474
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 476
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 475
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleCapture(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleCaptureContext,0)


        def initcapture(self):
            return self.getTypedRuleContext(CPP14Parser.InitcaptureContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_capture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCapture" ):
                listener.enterCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCapture" ):
                listener.exitCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCapture" ):
                return visitor.visitCapture(self)
            else:
                return visitor.visitChildren(self)




    def capture(self):

        localctx = CPP14Parser.CaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_capture)
        try:
            self.state = 480
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 478
                self.simpleCapture()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 479
                self.initcapture()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleCaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def This(self):
            return self.getToken(CPP14Parser.This, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleCapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleCapture" ):
                listener.enterSimpleCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleCapture" ):
                listener.exitSimpleCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleCapture" ):
                return visitor.visitSimpleCapture(self)
            else:
                return visitor.visitChildren(self)




    def simpleCapture(self):

        localctx = CPP14Parser.SimpleCaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_simpleCapture)
        self._la = 0 # Token type
        try:
            self.state = 487
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [97, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 483
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==97:
                    self.state = 482
                    self.match(CPP14Parser.And)


                self.state = 485
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 2)
                self.state = 486
                self.match(CPP14Parser.This)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitcaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def initializer(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)


        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initcapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitcapture" ):
                listener.enterInitcapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitcapture" ):
                listener.exitInitcapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitcapture" ):
                return visitor.visitInitcapture(self)
            else:
                return visitor.visitChildren(self)




    def initcapture(self):

        localctx = CPP14Parser.InitcaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_initcapture)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 490
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==97:
                self.state = 489
                self.match(CPP14Parser.And)


            self.state = 492
            self.match(CPP14Parser.Identifier)
            self.state = 493
            self.initializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def parameterDeclarationClause(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationClauseContext,0)


        def Mutable(self):
            return self.getToken(CPP14Parser.Mutable, 0)

        def exceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionSpecificationContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaDeclarator" ):
                listener.enterLambdaDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaDeclarator" ):
                listener.exitLambdaDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaDeclarator" ):
                return visitor.visitLambdaDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def lambdaDeclarator(self):

        localctx = CPP14Parser.LambdaDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_lambdaDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 495
            self.match(CPP14Parser.LeftParen)
            self.state = 497
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1237504995584196377) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 297237575406461917) != 0:
                self.state = 496
                self.parameterDeclarationClause()


            self.state = 499
            self.match(CPP14Parser.RightParen)
            self.state = 501
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==47:
                self.state = 500
                self.match(CPP14Parser.Mutable)


            self.state = 504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==50 or _la==71:
                self.state = 503
                self.exceptionSpecification()


            self.state = 507
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 506
                self.attributeSpecifierSeq()


            self.state = 510
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==124:
                self.state = 509
                self.trailingReturnType()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PostfixExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PrimaryExpressionContext,0)


        def simpleTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSpecifierContext,0)


        def typeNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeNameSpecifierContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Dynamic_cast(self):
            return self.getToken(CPP14Parser.Dynamic_cast, 0)

        def Static_cast(self):
            return self.getToken(CPP14Parser.Static_cast, 0)

        def Reinterpret_cast(self):
            return self.getToken(CPP14Parser.Reinterpret_cast, 0)

        def Const_cast(self):
            return self.getToken(CPP14Parser.Const_cast, 0)

        def typeIdOfTheTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TypeIdOfTheTypeIdContext,0)


        def postfixExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PostfixExpressionContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def Dot(self):
            return self.getToken(CPP14Parser.Dot, 0)

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def pseudoDestructorName(self):
            return self.getTypedRuleContext(CPP14Parser.PseudoDestructorNameContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_postfixExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPostfixExpression" ):
                listener.enterPostfixExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPostfixExpression" ):
                listener.exitPostfixExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPostfixExpression" ):
                return visitor.visitPostfixExpression(self)
            else:
                return visitor.visitChildren(self)



    def postfixExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.PostfixExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 30
        self.enterRecursionRule(localctx, 30, self.RULE_postfixExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 542
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 513
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 516
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [13, 14, 18, 19, 20, 26, 30, 39, 45, 46, 60, 61, 78, 81, 83, 127, 132]:
                    self.state = 514
                    self.simpleTypeSpecifier()
                    pass
                elif token in [76]:
                    self.state = 515
                    self.typeNameSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 524
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85]:
                    self.state = 518
                    self.match(CPP14Parser.LeftParen)
                    self.state = 520
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474400910417) != 0 or _la==132:
                        self.state = 519
                        self.expressionList()


                    self.state = 522
                    self.match(CPP14Parser.RightParen)
                    pass
                elif token in [89]:
                    self.state = 523
                    self.bracedInitList()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 3:
                self.state = 526
                _la = self._input.LA(1)
                if not((((_la - 24)) & ~0x3f) == 0 and ((1 << (_la - 24)) & 2216203124865) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 527
                self.match(CPP14Parser.Less)
                self.state = 528
                self.theTypeId()
                self.state = 529
                self.match(CPP14Parser.Greater)
                self.state = 530
                self.match(CPP14Parser.LeftParen)
                self.state = 531
                self.expression()
                self.state = 532
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 4:
                self.state = 534
                self.typeIdOfTheTypeId()
                self.state = 535
                self.match(CPP14Parser.LeftParen)
                self.state = 538
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                if la_ == 1:
                    self.state = 536
                    self.expression()
                    pass

                elif la_ == 2:
                    self.state = 537
                    self.theTypeId()
                    pass


                self.state = 540
                self.match(CPP14Parser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 571
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 569
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                    if la_ == 1:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 544
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 545
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 548
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 18, 19, 20, 24, 26, 28, 30, 31, 39, 45, 46, 49, 50, 52, 58, 60, 61, 62, 65, 69, 71, 75, 76, 78, 81, 83, 85, 87, 91, 92, 93, 97, 98, 99, 100, 120, 121, 127, 132]:
                            self.state = 546
                            self.expression()
                            pass
                        elif token in [89]:
                            self.state = 547
                            self.bracedInitList()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 550
                        self.match(CPP14Parser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 552
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 553
                        self.match(CPP14Parser.LeftParen)
                        self.state = 555
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474400910417) != 0 or _la==132:
                            self.state = 554
                            self.expressionList()


                        self.state = 557
                        self.match(CPP14Parser.RightParen)
                        pass

                    elif la_ == 3:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 558
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 559
                        _la = self._input.LA(1)
                        if not(_la==124 or _la==129):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 565
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                        if la_ == 1:
                            self.state = 561
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la==68:
                                self.state = 560
                                self.match(CPP14Parser.Template)


                            self.state = 563
                            self.idExpression()
                            pass

                        elif la_ == 2:
                            self.state = 564
                            self.pseudoDestructorName()
                            pass


                        pass

                    elif la_ == 4:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 567
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 568
                        _la = self._input.LA(1)
                        if not(_la==120 or _la==121):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

             
                self.state = 573
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class TypeIdOfTheTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Typeid_(self):
            return self.getToken(CPP14Parser.Typeid_, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeIdOfTheTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeIdOfTheTypeId" ):
                listener.enterTypeIdOfTheTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeIdOfTheTypeId" ):
                listener.exitTypeIdOfTheTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeIdOfTheTypeId" ):
                return visitor.visitTypeIdOfTheTypeId(self)
            else:
                return visitor.visitChildren(self)




    def typeIdOfTheTypeId(self):

        localctx = CPP14Parser.TypeIdOfTheTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_typeIdOfTheTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 574
            self.match(CPP14Parser.Typeid_)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initializerList(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_expressionList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionList" ):
                listener.enterExpressionList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionList" ):
                listener.exitExpressionList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionList" ):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)




    def expressionList(self):

        localctx = CPP14Parser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_expressionList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.initializerList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PseudoDestructorNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def theTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TheTypeNameContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,i)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pseudoDestructorName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPseudoDestructorName" ):
                listener.enterPseudoDestructorName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPseudoDestructorName" ):
                listener.exitPseudoDestructorName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPseudoDestructorName" ):
                return visitor.visitPseudoDestructorName(self)
            else:
                return visitor.visitChildren(self)




    def pseudoDestructorName(self):

        localctx = CPP14Parser.PseudoDestructorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_pseudoDestructorName)
        self._la = 0 # Token type
        try:
            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 579
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                if la_ == 1:
                    self.state = 578
                    self.nestedNameSpecifier(0)


                self.state = 584
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==132:
                    self.state = 581
                    self.theTypeName()
                    self.state = 582
                    self.match(CPP14Parser.Doublecolon)


                self.state = 586
                self.match(CPP14Parser.Tilde)
                self.state = 587
                self.theTypeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 588
                self.nestedNameSpecifier(0)
                self.state = 589
                self.match(CPP14Parser.Template)
                self.state = 590
                self.simpleTemplateId()
                self.state = 591
                self.match(CPP14Parser.Doublecolon)
                self.state = 592
                self.match(CPP14Parser.Tilde)
                self.state = 593
                self.theTypeName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 595
                self.match(CPP14Parser.Tilde)
                self.state = 596
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def postfixExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PostfixExpressionContext,0)


        def unaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryExpressionContext,0)


        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def unaryOperator(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryOperatorContext,0)


        def Sizeof(self):
            return self.getToken(CPP14Parser.Sizeof, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Alignof(self):
            return self.getToken(CPP14Parser.Alignof, 0)

        def noExceptExpression(self):
            return self.getTypedRuleContext(CPP14Parser.NoExceptExpressionContext,0)


        def newExpression(self):
            return self.getTypedRuleContext(CPP14Parser.NewExpressionContext,0)


        def deleteExpression(self):
            return self.getTypedRuleContext(CPP14Parser.DeleteExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_unaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryExpression" ):
                listener.enterUnaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryExpression" ):
                listener.exitUnaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnaryExpression" ):
                return visitor.visitUnaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def unaryExpression(self):

        localctx = CPP14Parser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_unaryExpression)
        try:
            self.state = 626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 599
                self.postfixExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 604
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [120]:
                    self.state = 600
                    self.match(CPP14Parser.PlusPlus)
                    pass
                elif token in [121]:
                    self.state = 601
                    self.match(CPP14Parser.MinusMinus)
                    pass
                elif token in [91, 92, 93, 97, 98, 99, 100]:
                    self.state = 602
                    self.unaryOperator()
                    pass
                elif token in [62]:
                    self.state = 603
                    self.match(CPP14Parser.Sizeof)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 606
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 607
                self.match(CPP14Parser.Sizeof)
                self.state = 616
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85]:
                    self.state = 608
                    self.match(CPP14Parser.LeftParen)
                    self.state = 609
                    self.theTypeId()
                    self.state = 610
                    self.match(CPP14Parser.RightParen)
                    pass
                elif token in [131]:
                    self.state = 612
                    self.match(CPP14Parser.Ellipsis)
                    self.state = 613
                    self.match(CPP14Parser.LeftParen)
                    self.state = 614
                    self.match(CPP14Parser.Identifier)
                    self.state = 615
                    self.match(CPP14Parser.RightParen)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 618
                self.match(CPP14Parser.Alignof)
                self.state = 619
                self.match(CPP14Parser.LeftParen)
                self.state = 620
                self.theTypeId()
                self.state = 621
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 623
                self.noExceptExpression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 624
                self.newExpression()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 625
                self.deleteExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Or(self):
            return self.getToken(CPP14Parser.Or, 0)

        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Plus(self):
            return self.getToken(CPP14Parser.Plus, 0)

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def Minus(self):
            return self.getToken(CPP14Parser.Minus, 0)

        def Not(self):
            return self.getToken(CPP14Parser.Not, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_unaryOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryOperator" ):
                listener.enterUnaryOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryOperator" ):
                listener.exitUnaryOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnaryOperator" ):
                return visitor.visitUnaryOperator(self)
            else:
                return visitor.visitChildren(self)




    def unaryOperator(self):

        localctx = CPP14Parser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            _la = self._input.LA(1)
            if not((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 967) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def New(self):
            return self.getToken(CPP14Parser.New, 0)

        def newTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.NewTypeIdContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def newPlacement(self):
            return self.getTypedRuleContext(CPP14Parser.NewPlacementContext,0)


        def newInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.NewInitializerContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_newExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewExpression" ):
                listener.enterNewExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewExpression" ):
                listener.exitNewExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewExpression" ):
                return visitor.visitNewExpression(self)
            else:
                return visitor.visitChildren(self)




    def newExpression(self):

        localctx = CPP14Parser.NewExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_newExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==127:
                self.state = 630
                self.match(CPP14Parser.Doublecolon)


            self.state = 633
            self.match(CPP14Parser.New)
            self.state = 635
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 634
                self.newPlacement()


            self.state = 642
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13, 14, 18, 19, 20, 21, 22, 26, 30, 33, 39, 45, 46, 60, 61, 66, 76, 77, 78, 81, 82, 83, 127, 132]:
                self.state = 637
                self.newTypeId()
                pass
            elif token in [85]:
                self.state = 638
                self.match(CPP14Parser.LeftParen)
                self.state = 639
                self.theTypeId()
                self.state = 640
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 645
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==85 or _la==89:
                self.state = 644
                self.newInitializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewPlacementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_newPlacement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewPlacement" ):
                listener.enterNewPlacement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewPlacement" ):
                listener.exitNewPlacement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewPlacement" ):
                return visitor.visitNewPlacement(self)
            else:
                return visitor.visitChildren(self)




    def newPlacement(self):

        localctx = CPP14Parser.NewPlacementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_newPlacement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 647
            self.match(CPP14Parser.LeftParen)
            self.state = 648
            self.expressionList()
            self.state = 649
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def newDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NewDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewTypeId" ):
                listener.enterNewTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewTypeId" ):
                listener.exitNewTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewTypeId" ):
                return visitor.visitNewTypeId(self)
            else:
                return visitor.visitChildren(self)




    def newTypeId(self):

        localctx = CPP14Parser.NewTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_newTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 651
            self.typeSpecifierSeq()
            self.state = 653
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 652
                self.newDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerOperator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,0)


        def newDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NewDeclaratorContext,0)


        def noPointerNewDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerNewDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewDeclarator" ):
                listener.enterNewDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewDeclarator" ):
                listener.exitNewDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewDeclarator" ):
                return visitor.visitNewDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def newDeclarator(self):

        localctx = CPP14Parser.NewDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_newDeclarator)
        try:
            self.state = 660
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [26, 93, 97, 118, 127, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 655
                self.pointerOperator()
                self.state = 657
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
                if la_ == 1:
                    self.state = 656
                    self.newDeclarator()


                pass
            elif token in [87]:
                self.enterOuterAlt(localctx, 2)
                self.state = 659
                self.noPointerNewDeclarator(0)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerNewDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def noPointerNewDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerNewDeclaratorContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerNewDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerNewDeclarator" ):
                listener.enterNoPointerNewDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerNewDeclarator" ):
                listener.exitNoPointerNewDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerNewDeclarator" ):
                return visitor.visitNoPointerNewDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerNewDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerNewDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 50
        self.enterRecursionRule(localctx, 50, self.RULE_noPointerNewDeclarator, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 663
            self.match(CPP14Parser.LeftBracket)
            self.state = 664
            self.expression()
            self.state = 665
            self.match(CPP14Parser.RightBracket)
            self.state = 667
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.state = 666
                self.attributeSpecifierSeq()


            self._ctx.stop = self._input.LT(-1)
            self.state = 678
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerNewDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerNewDeclarator)
                    self.state = 669
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 670
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 671
                    self.constantExpression()
                    self.state = 672
                    self.match(CPP14Parser.RightBracket)
                    self.state = 674
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                    if la_ == 1:
                        self.state = 673
                        self.attributeSpecifierSeq()

             
                self.state = 680
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,52,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class NewInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewInitializer" ):
                listener.enterNewInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewInitializer" ):
                listener.exitNewInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewInitializer" ):
                return visitor.visitNewInitializer(self)
            else:
                return visitor.visitChildren(self)




    def newInitializer(self):

        localctx = CPP14Parser.NewInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_newInitializer)
        self._la = 0 # Token type
        try:
            self.state = 687
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [85]:
                self.enterOuterAlt(localctx, 1)
                self.state = 681
                self.match(CPP14Parser.LeftParen)
                self.state = 683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474400910417) != 0 or _la==132:
                    self.state = 682
                    self.expressionList()


                self.state = 685
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 686
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeleteExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def castExpression(self):
            return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_deleteExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeleteExpression" ):
                listener.enterDeleteExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeleteExpression" ):
                listener.exitDeleteExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeleteExpression" ):
                return visitor.visitDeleteExpression(self)
            else:
                return visitor.visitChildren(self)




    def deleteExpression(self):

        localctx = CPP14Parser.DeleteExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_deleteExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==127:
                self.state = 689
                self.match(CPP14Parser.Doublecolon)


            self.state = 692
            self.match(CPP14Parser.Delete)
            self.state = 695
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 693
                self.match(CPP14Parser.LeftBracket)
                self.state = 694
                self.match(CPP14Parser.RightBracket)


            self.state = 697
            self.castExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoExceptExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Noexcept(self):
            return self.getToken(CPP14Parser.Noexcept, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_noExceptExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoExceptExpression" ):
                listener.enterNoExceptExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoExceptExpression" ):
                listener.exitNoExceptExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoExceptExpression" ):
                return visitor.visitNoExceptExpression(self)
            else:
                return visitor.visitChildren(self)




    def noExceptExpression(self):

        localctx = CPP14Parser.NoExceptExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_noExceptExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 699
            self.match(CPP14Parser.Noexcept)
            self.state = 700
            self.match(CPP14Parser.LeftParen)
            self.state = 701
            self.expression()
            self.state = 702
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CastExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryExpressionContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def castExpression(self):
            return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_castExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCastExpression" ):
                listener.enterCastExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCastExpression" ):
                listener.exitCastExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCastExpression" ):
                return visitor.visitCastExpression(self)
            else:
                return visitor.visitChildren(self)




    def castExpression(self):

        localctx = CPP14Parser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_castExpression)
        try:
            self.state = 710
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 704
                self.unaryExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 705
                self.match(CPP14Parser.LeftParen)
                self.state = 706
                self.theTypeId()
                self.state = 707
                self.match(CPP14Parser.RightParen)
                self.state = 708
                self.castExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerMemberExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def castExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CastExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,i)


        def DotStar(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.DotStar)
            else:
                return self.getToken(CPP14Parser.DotStar, i)

        def ArrowStar(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.ArrowStar)
            else:
                return self.getToken(CPP14Parser.ArrowStar, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerMemberExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerMemberExpression" ):
                listener.enterPointerMemberExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerMemberExpression" ):
                listener.exitPointerMemberExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerMemberExpression" ):
                return visitor.visitPointerMemberExpression(self)
            else:
                return visitor.visitChildren(self)




    def pointerMemberExpression(self):

        localctx = CPP14Parser.PointerMemberExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_pointerMemberExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self.castExpression()
            self.state = 717
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==123 or _la==130:
                self.state = 713
                _la = self._input.LA(1)
                if not(_la==123 or _la==130):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 714
                self.castExpression()
                self.state = 719
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultiplicativeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerMemberExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerMemberExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerMemberExpressionContext,i)


        def Star(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Star)
            else:
                return self.getToken(CPP14Parser.Star, i)

        def Div(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Div)
            else:
                return self.getToken(CPP14Parser.Div, i)

        def Mod(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Mod)
            else:
                return self.getToken(CPP14Parser.Mod, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_multiplicativeExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMultiplicativeExpression" ):
                listener.enterMultiplicativeExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMultiplicativeExpression" ):
                listener.exitMultiplicativeExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiplicativeExpression" ):
                return visitor.visitMultiplicativeExpression(self)
            else:
                return visitor.visitChildren(self)




    def multiplicativeExpression(self):

        localctx = CPP14Parser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.pointerMemberExpression()
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & 7) != 0:
                self.state = 721
                _la = self._input.LA(1)
                if not((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & 7) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 722
                self.pointerMemberExpression()
                self.state = 727
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def multiplicativeExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MultiplicativeExpressionContext,i)


        def Plus(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Plus)
            else:
                return self.getToken(CPP14Parser.Plus, i)

        def Minus(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Minus)
            else:
                return self.getToken(CPP14Parser.Minus, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_additiveExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAdditiveExpression" ):
                listener.enterAdditiveExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAdditiveExpression" ):
                listener.exitAdditiveExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAdditiveExpression" ):
                return visitor.visitAdditiveExpression(self)
            else:
                return visitor.visitChildren(self)




    def additiveExpression(self):

        localctx = CPP14Parser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.multiplicativeExpression()
            self.state = 733
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==91 or _la==92:
                self.state = 729
                _la = self._input.LA(1)
                if not(_la==91 or _la==92):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 730
                self.multiplicativeExpression()
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShiftExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def additiveExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AdditiveExpressionContext,i)


        def shiftOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ShiftOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ShiftOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_shiftExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShiftExpression" ):
                listener.enterShiftExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShiftExpression" ):
                listener.exitShiftExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShiftExpression" ):
                return visitor.visitShiftExpression(self)
            else:
                return visitor.visitChildren(self)




    def shiftExpression(self):

        localctx = CPP14Parser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_shiftExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            self.additiveExpression()
            self.state = 742
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 737
                    self.shiftOperator()
                    self.state = 738
                    self.additiveExpression() 
                self.state = 744
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShiftOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_shiftOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShiftOperator" ):
                listener.enterShiftOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShiftOperator" ):
                listener.exitShiftOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShiftOperator" ):
                return visitor.visitShiftOperator(self)
            else:
                return visitor.visitChildren(self)




    def shiftOperator(self):

        localctx = CPP14Parser.ShiftOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_shiftOperator)
        try:
            self.state = 749
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [103]:
                self.enterOuterAlt(localctx, 1)
                self.state = 745
                self.match(CPP14Parser.Greater)
                self.state = 746
                self.match(CPP14Parser.Greater)
                pass
            elif token in [102]:
                self.enterOuterAlt(localctx, 2)
                self.state = 747
                self.match(CPP14Parser.Less)
                self.state = 748
                self.match(CPP14Parser.Less)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def shiftExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ShiftExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ShiftExpressionContext,i)


        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def LessEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LessEqual)
            else:
                return self.getToken(CPP14Parser.LessEqual, i)

        def GreaterEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.GreaterEqual)
            else:
                return self.getToken(CPP14Parser.GreaterEqual, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_relationalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelationalExpression" ):
                listener.enterRelationalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelationalExpression" ):
                listener.exitRelationalExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelationalExpression" ):
                return visitor.visitRelationalExpression(self)
            else:
                return visitor.visitChildren(self)




    def relationalExpression(self):

        localctx = CPP14Parser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 751
            self.shiftExpression()
            self.state = 756
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,63,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 752
                    _la = self._input.LA(1)
                    if not((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & 49155) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 753
                    self.shiftExpression() 
                self.state = 758
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,63,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EqualityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def relationalExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.RelationalExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.RelationalExpressionContext,i)


        def Equal(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Equal)
            else:
                return self.getToken(CPP14Parser.Equal, i)

        def NotEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.NotEqual)
            else:
                return self.getToken(CPP14Parser.NotEqual, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_equalityExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEqualityExpression" ):
                listener.enterEqualityExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEqualityExpression" ):
                listener.exitEqualityExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEqualityExpression" ):
                return visitor.visitEqualityExpression(self)
            else:
                return visitor.visitChildren(self)




    def equalityExpression(self):

        localctx = CPP14Parser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 759
            self.relationalExpression()
            self.state = 764
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==114 or _la==115:
                self.state = 760
                _la = self._input.LA(1)
                if not(_la==114 or _la==115):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 761
                self.relationalExpression()
                self.state = 766
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def equalityExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.EqualityExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.EqualityExpressionContext,i)


        def And(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.And)
            else:
                return self.getToken(CPP14Parser.And, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_andExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAndExpression" ):
                listener.enterAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAndExpression" ):
                listener.exitAndExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAndExpression" ):
                return visitor.visitAndExpression(self)
            else:
                return visitor.visitChildren(self)




    def andExpression(self):

        localctx = CPP14Parser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 767
            self.equalityExpression()
            self.state = 772
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==97:
                self.state = 768
                self.match(CPP14Parser.And)
                self.state = 769
                self.equalityExpression()
                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def andExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AndExpressionContext,i)


        def Caret(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Caret)
            else:
                return self.getToken(CPP14Parser.Caret, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_exclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExclusiveOrExpression" ):
                listener.enterExclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExclusiveOrExpression" ):
                listener.exitExclusiveOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExclusiveOrExpression" ):
                return visitor.visitExclusiveOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def exclusiveOrExpression(self):

        localctx = CPP14Parser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 775
            self.andExpression()
            self.state = 780
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==96:
                self.state = 776
                self.match(CPP14Parser.Caret)
                self.state = 777
                self.andExpression()
                self.state = 782
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def exclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ExclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ExclusiveOrExpressionContext,i)


        def Or(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Or)
            else:
                return self.getToken(CPP14Parser.Or, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_inclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInclusiveOrExpression" ):
                listener.enterInclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInclusiveOrExpression" ):
                listener.exitInclusiveOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInclusiveOrExpression" ):
                return visitor.visitInclusiveOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def inclusiveOrExpression(self):

        localctx = CPP14Parser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.exclusiveOrExpression()
            self.state = 788
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==98:
                self.state = 784
                self.match(CPP14Parser.Or)
                self.state = 785
                self.exclusiveOrExpression()
                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InclusiveOrExpressionContext,i)


        def AndAnd(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.AndAnd)
            else:
                return self.getToken(CPP14Parser.AndAnd, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_logicalAndExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogicalAndExpression" ):
                listener.enterLogicalAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogicalAndExpression" ):
                listener.exitLogicalAndExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalAndExpression" ):
                return visitor.visitLogicalAndExpression(self)
            else:
                return visitor.visitChildren(self)




    def logicalAndExpression(self):

        localctx = CPP14Parser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 791
            self.inclusiveOrExpression()
            self.state = 796
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==118:
                self.state = 792
                self.match(CPP14Parser.AndAnd)
                self.state = 793
                self.inclusiveOrExpression()
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logicalAndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.LogicalAndExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.LogicalAndExpressionContext,i)


        def OrOr(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.OrOr)
            else:
                return self.getToken(CPP14Parser.OrOr, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_logicalOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogicalOrExpression" ):
                listener.enterLogicalOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogicalOrExpression" ):
                listener.exitLogicalOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalOrExpression" ):
                return visitor.visitLogicalOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def logicalOrExpression(self):

        localctx = CPP14Parser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 799
            self.logicalAndExpression()
            self.state = 804
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==119:
                self.state = 800
                self.match(CPP14Parser.OrOr)
                self.state = 801
                self.logicalAndExpression()
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logicalOrExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LogicalOrExpressionContext,0)


        def Question(self):
            return self.getToken(CPP14Parser.Question, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conditionalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConditionalExpression" ):
                listener.enterConditionalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConditionalExpression" ):
                listener.exitConditionalExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConditionalExpression" ):
                return visitor.visitConditionalExpression(self)
            else:
                return visitor.visitChildren(self)




    def conditionalExpression(self):

        localctx = CPP14Parser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 807
            self.logicalOrExpression()
            self.state = 813
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==125:
                self.state = 808
                self.match(CPP14Parser.Question)
                self.state = 809
                self.expression()
                self.state = 810
                self.match(CPP14Parser.Colon)
                self.state = 811
                self.assignmentExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conditionalExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionalExpressionContext,0)


        def logicalOrExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LogicalOrExpressionContext,0)


        def assignmentOperator(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentOperatorContext,0)


        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def throwExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ThrowExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_assignmentExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignmentExpression" ):
                listener.enterAssignmentExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignmentExpression" ):
                listener.exitAssignmentExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignmentExpression" ):
                return visitor.visitAssignmentExpression(self)
            else:
                return visitor.visitChildren(self)




    def assignmentExpression(self):

        localctx = CPP14Parser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_assignmentExpression)
        try:
            self.state = 821
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 815
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 816
                self.logicalOrExpression()
                self.state = 817
                self.assignmentOperator()
                self.state = 818
                self.initializerClause()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 820
                self.throwExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def StarAssign(self):
            return self.getToken(CPP14Parser.StarAssign, 0)

        def DivAssign(self):
            return self.getToken(CPP14Parser.DivAssign, 0)

        def ModAssign(self):
            return self.getToken(CPP14Parser.ModAssign, 0)

        def PlusAssign(self):
            return self.getToken(CPP14Parser.PlusAssign, 0)

        def MinusAssign(self):
            return self.getToken(CPP14Parser.MinusAssign, 0)

        def RightShiftAssign(self):
            return self.getToken(CPP14Parser.RightShiftAssign, 0)

        def LeftShiftAssign(self):
            return self.getToken(CPP14Parser.LeftShiftAssign, 0)

        def AndAssign(self):
            return self.getToken(CPP14Parser.AndAssign, 0)

        def XorAssign(self):
            return self.getToken(CPP14Parser.XorAssign, 0)

        def OrAssign(self):
            return self.getToken(CPP14Parser.OrAssign, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_assignmentOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignmentOperator" ):
                listener.enterAssignmentOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignmentOperator" ):
                listener.exitAssignmentOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignmentOperator" ):
                return visitor.visitAssignmentOperator(self)
            else:
                return visitor.visitChildren(self)




    def assignmentOperator(self):

        localctx = CPP14Parser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 823
            _la = self._input.LA(1)
            if not((((_la - 101)) & ~0x3f) == 0 and ((1 << (_la - 101)) & 8185) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignmentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)




    def expression(self):

        localctx = CPP14Parser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 825
            self.assignmentExpression()
            self.state = 830
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 826
                self.match(CPP14Parser.Comma)
                self.state = 827
                self.assignmentExpression()
                self.state = 832
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conditionalExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_constantExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstantExpression" ):
                listener.enterConstantExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstantExpression" ):
                listener.exitConstantExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstantExpression" ):
                return visitor.visitConstantExpression(self)
            else:
                return visitor.visitChildren(self)




    def constantExpression(self):

        localctx = CPP14Parser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 833
            self.conditionalExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def labeledStatement(self):
            return self.getTypedRuleContext(CPP14Parser.LabeledStatementContext,0)


        def declarationStatement(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionStatementContext,0)


        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def selectionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.SelectionStatementContext,0)


        def iterationStatement(self):
            return self.getTypedRuleContext(CPP14Parser.IterationStatementContext,0)


        def jumpStatement(self):
            return self.getTypedRuleContext(CPP14Parser.JumpStatementContext,0)


        def tryBlock(self):
            return self.getTypedRuleContext(CPP14Parser.TryBlockContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = CPP14Parser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_statement)
        try:
            self.state = 848
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 835
                self.labeledStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 836
                self.declarationStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 838
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 837
                    self.attributeSpecifierSeq()


                self.state = 846
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 18, 19, 20, 24, 26, 28, 30, 31, 39, 45, 46, 49, 50, 52, 58, 60, 61, 62, 65, 69, 71, 75, 76, 78, 81, 83, 85, 87, 91, 92, 93, 97, 98, 99, 100, 120, 121, 127, 128, 132]:
                    self.state = 840
                    self.expressionStatement()
                    pass
                elif token in [89]:
                    self.state = 841
                    self.compoundStatement()
                    pass
                elif token in [43, 67]:
                    self.state = 842
                    self.selectionStatement()
                    pass
                elif token in [29, 40, 84]:
                    self.state = 843
                    self.iterationStatement()
                    pass
                elif token in [15, 25, 42, 59]:
                    self.state = 844
                    self.jumpStatement()
                    pass
                elif token in [73]:
                    self.state = 845
                    self.tryBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabeledStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def statement(self):
            return self.getTypedRuleContext(CPP14Parser.StatementContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Case(self):
            return self.getToken(CPP14Parser.Case, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Default(self):
            return self.getToken(CPP14Parser.Default, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_labeledStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabeledStatement" ):
                listener.enterLabeledStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabeledStatement" ):
                listener.exitLabeledStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabeledStatement" ):
                return visitor.visitLabeledStatement(self)
            else:
                return visitor.visitChildren(self)




    def labeledStatement(self):

        localctx = CPP14Parser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_labeledStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 850
                self.attributeSpecifierSeq()


            self.state = 857
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [132]:
                self.state = 853
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [16]:
                self.state = 854
                self.match(CPP14Parser.Case)
                self.state = 855
                self.constantExpression()
                pass
            elif token in [27]:
                self.state = 856
                self.match(CPP14Parser.Default)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 859
            self.match(CPP14Parser.Colon)
            self.state = 860
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_expressionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionStatement" ):
                listener.enterExpressionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionStatement" ):
                listener.exitExpressionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionStatement" ):
                return visitor.visitExpressionStatement(self)
            else:
                return visitor.visitChildren(self)




    def expressionStatement(self):

        localctx = CPP14Parser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 863
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133201) != 0 or _la==132:
                self.state = 862
                self.expression()


            self.state = 865
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CompoundStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def statementSeq(self):
            return self.getTypedRuleContext(CPP14Parser.StatementSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_compoundStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCompoundStatement" ):
                listener.enterCompoundStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCompoundStatement" ):
                listener.exitCompoundStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCompoundStatement" ):
                return visitor.visitCompoundStatement(self)
            else:
                return visitor.visitChildren(self)




    def compoundStatement(self):

        localctx = CPP14Parser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.match(CPP14Parser.LeftBrace)
            self.state = 869
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -137360239606498050) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8989184726396829969) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 25) != 0:
                self.state = 868
                self.statementSeq()


            self.state = 871
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.StatementContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.StatementContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_statementSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatementSeq" ):
                listener.enterStatementSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatementSeq" ):
                listener.exitStatementSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatementSeq" ):
                return visitor.visitStatementSeq(self)
            else:
                return visitor.visitChildren(self)




    def statementSeq(self):

        localctx = CPP14Parser.StatementSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_statementSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 874 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 873
                self.statement()
                self.state = 876 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((_la) & ~0x3f) == 0 and ((1 << _la) & -137360239606498050) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -8989184726396829969) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 25) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def If(self):
            return self.getToken(CPP14Parser.If, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def condition(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.StatementContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.StatementContext,i)


        def Else(self):
            return self.getToken(CPP14Parser.Else, 0)

        def Switch(self):
            return self.getToken(CPP14Parser.Switch, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_selectionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelectionStatement" ):
                listener.enterSelectionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelectionStatement" ):
                listener.exitSelectionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectionStatement" ):
                return visitor.visitSelectionStatement(self)
            else:
                return visitor.visitChildren(self)




    def selectionStatement(self):

        localctx = CPP14Parser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_selectionStatement)
        try:
            self.state = 893
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [43]:
                self.enterOuterAlt(localctx, 1)
                self.state = 878
                self.match(CPP14Parser.If)
                self.state = 879
                self.match(CPP14Parser.LeftParen)
                self.state = 880
                self.condition()
                self.state = 881
                self.match(CPP14Parser.RightParen)
                self.state = 882
                self.statement()
                self.state = 885
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                if la_ == 1:
                    self.state = 883
                    self.match(CPP14Parser.Else)
                    self.state = 884
                    self.statement()


                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 2)
                self.state = 887
                self.match(CPP14Parser.Switch)
                self.state = 888
                self.match(CPP14Parser.LeftParen)
                self.state = 889
                self.condition()
                self.state = 890
                self.match(CPP14Parser.RightParen)
                self.state = 891
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_condition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCondition" ):
                listener.enterCondition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCondition" ):
                listener.exitCondition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCondition" ):
                return visitor.visitCondition(self)
            else:
                return visitor.visitChildren(self)




    def condition(self):

        localctx = CPP14Parser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_condition)
        self._la = 0 # Token type
        try:
            self.state = 906
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 895
                self.expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 897
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10 or _la==87:
                    self.state = 896
                    self.attributeSpecifierSeq()


                self.state = 899
                self.declSpecifierSeq()
                self.state = 900
                self.declarator()
                self.state = 904
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [101]:
                    self.state = 901
                    self.match(CPP14Parser.Assign)
                    self.state = 902
                    self.initializerClause()
                    pass
                elif token in [89]:
                    self.state = 903
                    self.bracedInitList()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IterationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def While(self):
            return self.getToken(CPP14Parser.While, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def condition(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def statement(self):
            return self.getTypedRuleContext(CPP14Parser.StatementContext,0)


        def Do(self):
            return self.getToken(CPP14Parser.Do, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def For(self):
            return self.getToken(CPP14Parser.For, 0)

        def forInitStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ForInitStatementContext,0)


        def forRangeDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ForRangeDeclarationContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def forRangeInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ForRangeInitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_iterationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIterationStatement" ):
                listener.enterIterationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIterationStatement" ):
                listener.exitIterationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIterationStatement" ):
                return visitor.visitIterationStatement(self)
            else:
                return visitor.visitChildren(self)




    def iterationStatement(self):

        localctx = CPP14Parser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_iterationStatement)
        self._la = 0 # Token type
        try:
            self.state = 941
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [84]:
                self.enterOuterAlt(localctx, 1)
                self.state = 908
                self.match(CPP14Parser.While)
                self.state = 909
                self.match(CPP14Parser.LeftParen)
                self.state = 910
                self.condition()
                self.state = 911
                self.match(CPP14Parser.RightParen)
                self.state = 912
                self.statement()
                pass
            elif token in [29]:
                self.enterOuterAlt(localctx, 2)
                self.state = 914
                self.match(CPP14Parser.Do)
                self.state = 915
                self.statement()
                self.state = 916
                self.match(CPP14Parser.While)
                self.state = 917
                self.match(CPP14Parser.LeftParen)
                self.state = 918
                self.expression()
                self.state = 919
                self.match(CPP14Parser.RightParen)
                self.state = 920
                self.match(CPP14Parser.Semi)
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 3)
                self.state = 922
                self.match(CPP14Parser.For)
                self.state = 923
                self.match(CPP14Parser.LeftParen)
                self.state = 936
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                if la_ == 1:
                    self.state = 924
                    self.forInitStatement()
                    self.state = 926
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & -714116761242538754) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384301683) != 0 or _la==132:
                        self.state = 925
                        self.condition()


                    self.state = 928
                    self.match(CPP14Parser.Semi)
                    self.state = 930
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133201) != 0 or _la==132:
                        self.state = 929
                        self.expression()


                    pass

                elif la_ == 2:
                    self.state = 932
                    self.forRangeDeclaration()
                    self.state = 933
                    self.match(CPP14Parser.Colon)
                    self.state = 934
                    self.forRangeInitializer()
                    pass


                self.state = 938
                self.match(CPP14Parser.RightParen)
                self.state = 939
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForInitStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expressionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionStatementContext,0)


        def simpleDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forInitStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForInitStatement" ):
                listener.enterForInitStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForInitStatement" ):
                listener.exitForInitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForInitStatement" ):
                return visitor.visitForInitStatement(self)
            else:
                return visitor.visitChildren(self)




    def forInitStatement(self):

        localctx = CPP14Parser.ForInitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_forInitStatement)
        try:
            self.state = 945
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 943
                self.expressionStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 944
                self.simpleDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForRangeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forRangeDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForRangeDeclaration" ):
                listener.enterForRangeDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForRangeDeclaration" ):
                listener.exitForRangeDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForRangeDeclaration" ):
                return visitor.visitForRangeDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def forRangeDeclaration(self):

        localctx = CPP14Parser.ForRangeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_forRangeDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 948
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 947
                self.attributeSpecifierSeq()


            self.state = 950
            self.declSpecifierSeq()
            self.state = 951
            self.declarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForRangeInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forRangeInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForRangeInitializer" ):
                listener.enterForRangeInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForRangeInitializer" ):
                listener.exitForRangeInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForRangeInitializer" ):
                return visitor.visitForRangeInitializer(self)
            else:
                return visitor.visitChildren(self)




    def forRangeInitializer(self):

        localctx = CPP14Parser.ForRangeInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_forRangeInitializer)
        try:
            self.state = 955
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 18, 19, 20, 24, 26, 28, 30, 31, 39, 45, 46, 49, 50, 52, 58, 60, 61, 62, 65, 69, 71, 75, 76, 78, 81, 83, 85, 87, 91, 92, 93, 97, 98, 99, 100, 120, 121, 127, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 953
                self.expression()
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 954
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JumpStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Break(self):
            return self.getToken(CPP14Parser.Break, 0)

        def Continue(self):
            return self.getToken(CPP14Parser.Continue, 0)

        def Return(self):
            return self.getToken(CPP14Parser.Return, 0)

        def Goto(self):
            return self.getToken(CPP14Parser.Goto, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_jumpStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJumpStatement" ):
                listener.enterJumpStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJumpStatement" ):
                listener.exitJumpStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJumpStatement" ):
                return visitor.visitJumpStatement(self)
            else:
                return visitor.visitChildren(self)




    def jumpStatement(self):

        localctx = CPP14Parser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_jumpStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 966
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [15]:
                self.state = 957
                self.match(CPP14Parser.Break)
                pass
            elif token in [25]:
                self.state = 958
                self.match(CPP14Parser.Continue)
                pass
            elif token in [59]:
                self.state = 959
                self.match(CPP14Parser.Return)
                self.state = 962
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 18, 19, 20, 24, 26, 28, 30, 31, 39, 45, 46, 49, 50, 52, 58, 60, 61, 62, 65, 69, 71, 75, 76, 78, 81, 83, 85, 87, 91, 92, 93, 97, 98, 99, 100, 120, 121, 127, 132]:
                    self.state = 960
                    self.expression()
                    pass
                elif token in [89]:
                    self.state = 961
                    self.bracedInitList()
                    pass
                elif token in [128]:
                    pass
                else:
                    pass
                pass
            elif token in [42]:
                self.state = 964
                self.match(CPP14Parser.Goto)
                self.state = 965
                self.match(CPP14Parser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 968
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def blockDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.BlockDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarationStatement" ):
                listener.enterDeclarationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarationStatement" ):
                listener.exitDeclarationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarationStatement" ):
                return visitor.visitDeclarationStatement(self)
            else:
                return visitor.visitChildren(self)




    def declarationStatement(self):

        localctx = CPP14Parser.DeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_declarationStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 970
            self.blockDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationseqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.DeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.DeclarationContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarationseq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarationseq" ):
                listener.enterDeclarationseq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarationseq" ):
                listener.exitDeclarationseq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarationseq" ):
                return visitor.visitDeclarationseq(self)
            else:
                return visitor.visitChildren(self)




    def declarationseq(self):

        localctx = CPP14Parser.DeclarationseqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_declarationseq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 973 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 972
                self.declaration()
                self.state = 975 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543754443169808157) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 459384754220313597) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def blockDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.BlockDeclarationContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionDefinitionContext,0)


        def templateDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateDeclarationContext,0)


        def explicitInstantiation(self):
            return self.getTypedRuleContext(CPP14Parser.ExplicitInstantiationContext,0)


        def explicitSpecialization(self):
            return self.getTypedRuleContext(CPP14Parser.ExplicitSpecializationContext,0)


        def linkageSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.LinkageSpecificationContext,0)


        def namespaceDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceDefinitionContext,0)


        def emptyDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.EmptyDeclarationContext,0)


        def attributeDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclaration" ):
                listener.enterDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclaration" ):
                listener.exitDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclaration" ):
                return visitor.visitDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def declaration(self):

        localctx = CPP14Parser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_declaration)
        try:
            self.state = 986
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 977
                self.blockDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 978
                self.functionDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 979
                self.templateDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 980
                self.explicitInstantiation()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 981
                self.explicitSpecialization()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 982
                self.linkageSpecification()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 983
                self.namespaceDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 984
                self.emptyDeclaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 985
                self.attributeDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleDeclarationContext,0)


        def asmDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.AsmDefinitionContext,0)


        def namespaceAliasDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceAliasDefinitionContext,0)


        def usingDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDeclarationContext,0)


        def usingDirective(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDirectiveContext,0)


        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.StaticAssertDeclarationContext,0)


        def aliasDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AliasDeclarationContext,0)


        def opaqueEnumDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.OpaqueEnumDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_blockDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBlockDeclaration" ):
                listener.enterBlockDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBlockDeclaration" ):
                listener.exitBlockDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlockDeclaration" ):
                return visitor.visitBlockDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def blockDeclaration(self):

        localctx = CPP14Parser.BlockDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_blockDeclaration)
        try:
            self.state = 996
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 988
                self.simpleDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 989
                self.asmDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 990
                self.namespaceAliasDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 991
                self.usingDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 992
                self.usingDirective()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 993
                self.staticAssertDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 994
                self.aliasDeclaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 995
                self.opaqueEnumDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AliasDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_aliasDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAliasDeclaration" ):
                listener.enterAliasDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAliasDeclaration" ):
                listener.exitAliasDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAliasDeclaration" ):
                return visitor.visitAliasDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def aliasDeclaration(self):

        localctx = CPP14Parser.AliasDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_aliasDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 998
            self.match(CPP14Parser.Using)
            self.state = 999
            self.match(CPP14Parser.Identifier)
            self.state = 1001
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1000
                self.attributeSpecifierSeq()


            self.state = 1003
            self.match(CPP14Parser.Assign)
            self.state = 1004
            self.theTypeId()
            self.state = 1005
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def initDeclaratorList(self):
            return self.getTypedRuleContext(CPP14Parser.InitDeclaratorListContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleDeclaration" ):
                listener.enterSimpleDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleDeclaration" ):
                listener.exitSimpleDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleDeclaration" ):
                return visitor.visitSimpleDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def simpleDeclaration(self):

        localctx = CPP14Parser.SimpleDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_simpleDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 1021
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13, 14, 18, 19, 20, 21, 22, 23, 26, 30, 33, 34, 36, 39, 41, 44, 45, 46, 47, 52, 57, 60, 61, 63, 66, 70, 74, 76, 77, 78, 80, 81, 82, 83, 85, 93, 97, 99, 118, 127, 128, 131, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1008
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 1007
                    self.declSpecifierSeq()


                self.state = 1011
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26 or _la==52 or (((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 215512868999425) != 0:
                    self.state = 1010
                    self.initDeclaratorList()


                self.state = 1013
                self.match(CPP14Parser.Semi)
                pass
            elif token in [10, 87]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1014
                self.attributeSpecifierSeq()
                self.state = 1016
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
                if la_ == 1:
                    self.state = 1015
                    self.declSpecifierSeq()


                self.state = 1018
                self.initDeclaratorList()
                self.state = 1019
                self.match(CPP14Parser.Semi)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticAssertDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Static_assert(self):
            return self.getToken(CPP14Parser.Static_assert, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_staticAssertDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStaticAssertDeclaration" ):
                listener.enterStaticAssertDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStaticAssertDeclaration" ):
                listener.exitStaticAssertDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticAssertDeclaration" ):
                return visitor.visitStaticAssertDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def staticAssertDeclaration(self):

        localctx = CPP14Parser.StaticAssertDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_staticAssertDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1023
            self.match(CPP14Parser.Static_assert)
            self.state = 1024
            self.match(CPP14Parser.LeftParen)
            self.state = 1025
            self.constantExpression()
            self.state = 1026
            self.match(CPP14Parser.Comma)
            self.state = 1027
            self.match(CPP14Parser.StringLiteral)
            self.state = 1028
            self.match(CPP14Parser.RightParen)
            self.state = 1029
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmptyDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_emptyDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmptyDeclaration" ):
                listener.enterEmptyDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmptyDeclaration" ):
                listener.exitEmptyDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmptyDeclaration" ):
                return visitor.visitEmptyDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def emptyDeclaration(self):

        localctx = CPP14Parser.EmptyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_emptyDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1031
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeDeclaration" ):
                listener.enterAttributeDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeDeclaration" ):
                listener.exitAttributeDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeDeclaration" ):
                return visitor.visitAttributeDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def attributeDeclaration(self):

        localctx = CPP14Parser.AttributeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_attributeDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1033
            self.attributeSpecifierSeq()
            self.state = 1034
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def storageClassSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.StorageClassSpecifierContext,0)


        def typeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierContext,0)


        def functionSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionSpecifierContext,0)


        def Friend(self):
            return self.getToken(CPP14Parser.Friend, 0)

        def Typedef(self):
            return self.getToken(CPP14Parser.Typedef, 0)

        def Constexpr(self):
            return self.getToken(CPP14Parser.Constexpr, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_declSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclSpecifier" ):
                listener.enterDeclSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclSpecifier" ):
                listener.exitDeclSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclSpecifier" ):
                return visitor.visitDeclSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def declSpecifier(self):

        localctx = CPP14Parser.DeclSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_declSpecifier)
        try:
            self.state = 1042
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36, 47, 57, 63, 70]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1036
                self.storageClassSpecifier()
                pass
            elif token in [13, 14, 18, 19, 20, 21, 22, 26, 30, 33, 39, 45, 46, 60, 61, 66, 76, 77, 78, 81, 82, 83, 127, 132]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1037
                self.typeSpecifier()
                pass
            elif token in [34, 44, 80]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1038
                self.functionSpecifier()
                pass
            elif token in [41]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1039
                self.match(CPP14Parser.Friend)
                pass
            elif token in [74]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1040
                self.match(CPP14Parser.Typedef)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1041
                self.match(CPP14Parser.Constexpr)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.DeclSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.DeclSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclSpecifierSeq" ):
                listener.enterDeclSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclSpecifierSeq" ):
                listener.exitDeclSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclSpecifierSeq" ):
                return visitor.visitDeclSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def declSpecifierSeq(self):

        localctx = CPP14Parser.DeclSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_declSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1045 
            self._errHandler.sync(self)
            _alt = 1+1
            while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1+1:
                    self.state = 1044
                    self.declSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1047 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,self._ctx)

            self.state = 1050
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 1049
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StorageClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Register(self):
            return self.getToken(CPP14Parser.Register, 0)

        def Static(self):
            return self.getToken(CPP14Parser.Static, 0)

        def Thread_local(self):
            return self.getToken(CPP14Parser.Thread_local, 0)

        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def Mutable(self):
            return self.getToken(CPP14Parser.Mutable, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_storageClassSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStorageClassSpecifier" ):
                listener.enterStorageClassSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStorageClassSpecifier" ):
                listener.exitStorageClassSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageClassSpecifier" ):
                return visitor.visitStorageClassSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def storageClassSpecifier(self):

        localctx = CPP14Parser.StorageClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1052
            _la = self._input.LA(1)
            if not((((_la - 36)) & ~0x3f) == 0 and ((1 << (_la - 36)) & 17316186113) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Inline(self):
            return self.getToken(CPP14Parser.Inline, 0)

        def Virtual(self):
            return self.getToken(CPP14Parser.Virtual, 0)

        def Explicit(self):
            return self.getToken(CPP14Parser.Explicit, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_functionSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionSpecifier" ):
                listener.enterFunctionSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionSpecifier" ):
                listener.exitFunctionSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionSpecifier" ):
                return visitor.visitFunctionSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def functionSpecifier(self):

        localctx = CPP14Parser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_functionSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1054
            _la = self._input.LA(1)
            if not((((_la - 34)) & ~0x3f) == 0 and ((1 << (_la - 34)) & 70368744178689) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypedefNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typedefName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypedefName" ):
                listener.enterTypedefName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypedefName" ):
                listener.exitTypedefName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypedefName" ):
                return visitor.visitTypedefName(self)
            else:
                return visitor.visitChildren(self)




    def typedefName(self):

        localctx = CPP14Parser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1056
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def trailingTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierContext,0)


        def classSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ClassSpecifierContext,0)


        def enumSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.EnumSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_typeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeSpecifier" ):
                listener.enterTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeSpecifier" ):
                listener.exitTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSpecifier" ):
                return visitor.visitTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def typeSpecifier(self):

        localctx = CPP14Parser.TypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_typeSpecifier)
        try:
            self.state = 1061
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1058
                self.trailingTypeSpecifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1059
                self.classSpecifier()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1060
                self.enumSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSpecifierContext,0)


        def elaboratedTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ElaboratedTypeSpecifierContext,0)


        def typeNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeNameSpecifierContext,0)


        def cvQualifier(self):
            return self.getTypedRuleContext(CPP14Parser.CvQualifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingTypeSpecifier" ):
                listener.enterTrailingTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingTypeSpecifier" ):
                listener.exitTrailingTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingTypeSpecifier" ):
                return visitor.visitTrailingTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def trailingTypeSpecifier(self):

        localctx = CPP14Parser.TrailingTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_trailingTypeSpecifier)
        try:
            self.state = 1067
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13, 14, 18, 19, 20, 26, 30, 39, 45, 46, 60, 61, 78, 81, 83, 127, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1063
                self.simpleTypeSpecifier()
                pass
            elif token in [21, 33, 66]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1064
                self.elaboratedTypeSpecifier()
                pass
            elif token in [76]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1065
                self.typeNameSpecifier()
                pass
            elif token in [22, 82]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1066
                self.cvQualifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TypeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TypeSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_typeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeSpecifierSeq" ):
                listener.enterTypeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeSpecifierSeq" ):
                listener.exitTypeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSpecifierSeq" ):
                return visitor.visitTypeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def typeSpecifierSeq(self):

        localctx = CPP14Parser.TypeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_typeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1070 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1069
                    self.typeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1072 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,self._ctx)

            self.state = 1075
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
            if la_ == 1:
                self.state = 1074
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingTypeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def trailingTypeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TrailingTypeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingTypeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingTypeSpecifierSeq" ):
                listener.enterTrailingTypeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingTypeSpecifierSeq" ):
                listener.exitTrailingTypeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingTypeSpecifierSeq" ):
                return visitor.visitTrailingTypeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def trailingTypeSpecifierSeq(self):

        localctx = CPP14Parser.TrailingTypeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_trailingTypeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1077
                    self.trailingTypeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1080 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,110,self._ctx)

            self.state = 1083
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.state = 1082
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeLengthModifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Short(self):
            return self.getToken(CPP14Parser.Short, 0)

        def Long(self):
            return self.getToken(CPP14Parser.Long, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeLengthModifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeLengthModifier" ):
                listener.enterSimpleTypeLengthModifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeLengthModifier" ):
                listener.exitSimpleTypeLengthModifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeLengthModifier" ):
                return visitor.visitSimpleTypeLengthModifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeLengthModifier(self):

        localctx = CPP14Parser.SimpleTypeLengthModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_simpleTypeLengthModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1085
            _la = self._input.LA(1)
            if not(_la==46 or _la==60):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeSignednessModifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Unsigned(self):
            return self.getToken(CPP14Parser.Unsigned, 0)

        def Signed(self):
            return self.getToken(CPP14Parser.Signed, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeSignednessModifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeSignednessModifier" ):
                listener.enterSimpleTypeSignednessModifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeSignednessModifier" ):
                listener.exitSimpleTypeSignednessModifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeSignednessModifier" ):
                return visitor.visitSimpleTypeSignednessModifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeSignednessModifier(self):

        localctx = CPP14Parser.SimpleTypeSignednessModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_simpleTypeSignednessModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1087
            _la = self._input.LA(1)
            if not(_la==61 or _la==78):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeName(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def simpleTypeSignednessModifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSignednessModifierContext,0)


        def simpleTypeLengthModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.SimpleTypeLengthModifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.SimpleTypeLengthModifierContext,i)


        def Char(self):
            return self.getToken(CPP14Parser.Char, 0)

        def Char16(self):
            return self.getToken(CPP14Parser.Char16, 0)

        def Char32(self):
            return self.getToken(CPP14Parser.Char32, 0)

        def Wchar(self):
            return self.getToken(CPP14Parser.Wchar, 0)

        def Bool(self):
            return self.getToken(CPP14Parser.Bool, 0)

        def Int(self):
            return self.getToken(CPP14Parser.Int, 0)

        def Float(self):
            return self.getToken(CPP14Parser.Float, 0)

        def Double(self):
            return self.getToken(CPP14Parser.Double, 0)

        def Void(self):
            return self.getToken(CPP14Parser.Void, 0)

        def Auto(self):
            return self.getToken(CPP14Parser.Auto, 0)

        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeSpecifier" ):
                listener.enterSimpleTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeSpecifier" ):
                listener.exitSimpleTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeSpecifier" ):
                return visitor.visitSimpleTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeSpecifier(self):

        localctx = CPP14Parser.SimpleTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_simpleTypeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1141
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1090
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 1089
                    self.nestedNameSpecifier(0)


                self.state = 1092
                self.theTypeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1093
                self.nestedNameSpecifier(0)
                self.state = 1094
                self.match(CPP14Parser.Template)
                self.state = 1095
                self.simpleTemplateId()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1097
                self.simpleTypeSignednessModifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1099
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1098
                    self.simpleTypeSignednessModifier()


                self.state = 1102 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1101
                        self.simpleTypeLengthModifier()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1104 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,114,self._ctx)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1107
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1106
                    self.simpleTypeSignednessModifier()


                self.state = 1109
                self.match(CPP14Parser.Char)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1111
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1110
                    self.simpleTypeSignednessModifier()


                self.state = 1113
                self.match(CPP14Parser.Char16)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1115
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1114
                    self.simpleTypeSignednessModifier()


                self.state = 1117
                self.match(CPP14Parser.Char32)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1118
                    self.simpleTypeSignednessModifier()


                self.state = 1121
                self.match(CPP14Parser.Wchar)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1122
                self.match(CPP14Parser.Bool)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1124
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==61 or _la==78:
                    self.state = 1123
                    self.simpleTypeSignednessModifier()


                self.state = 1129
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==46 or _la==60:
                    self.state = 1126
                    self.simpleTypeLengthModifier()
                    self.state = 1131
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1132
                self.match(CPP14Parser.Int)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1133
                self.match(CPP14Parser.Float)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==46 or _la==60:
                    self.state = 1134
                    self.simpleTypeLengthModifier()


                self.state = 1137
                self.match(CPP14Parser.Double)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1138
                self.match(CPP14Parser.Void)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1139
                self.match(CPP14Parser.Auto)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1140
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def enumName(self):
            return self.getTypedRuleContext(CPP14Parser.EnumNameContext,0)


        def typedefName(self):
            return self.getTypedRuleContext(CPP14Parser.TypedefNameContext,0)


        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_theTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheTypeName" ):
                listener.enterTheTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheTypeName" ):
                listener.exitTheTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheTypeName" ):
                return visitor.visitTheTypeName(self)
            else:
                return visitor.visitChildren(self)




    def theTypeName(self):

        localctx = CPP14Parser.TheTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_theTypeName)
        try:
            self.state = 1147
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1143
                self.className()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1144
                self.enumName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1145
                self.typedefName()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1146
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DecltypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Decltype(self):
            return self.getToken(CPP14Parser.Decltype, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Auto(self):
            return self.getToken(CPP14Parser.Auto, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_decltypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecltypeSpecifier" ):
                listener.enterDecltypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecltypeSpecifier" ):
                listener.exitDecltypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecltypeSpecifier" ):
                return visitor.visitDecltypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def decltypeSpecifier(self):

        localctx = CPP14Parser.DecltypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_decltypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1149
            self.match(CPP14Parser.Decltype)
            self.state = 1150
            self.match(CPP14Parser.LeftParen)
            self.state = 1153
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.state = 1151
                self.expression()
                pass

            elif la_ == 2:
                self.state = 1152
                self.match(CPP14Parser.Auto)
                pass


            self.state = 1155
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElaboratedTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classKey(self):
            return self.getTypedRuleContext(CPP14Parser.ClassKeyContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Enum(self):
            return self.getToken(CPP14Parser.Enum, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_elaboratedTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElaboratedTypeSpecifier" ):
                listener.enterElaboratedTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElaboratedTypeSpecifier" ):
                listener.exitElaboratedTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElaboratedTypeSpecifier" ):
                return visitor.visitElaboratedTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def elaboratedTypeSpecifier(self):

        localctx = CPP14Parser.ElaboratedTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_elaboratedTypeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1179
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [21, 66]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1157
                self.classKey()
                self.state = 1172
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
                if la_ == 1:
                    self.state = 1159
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==10 or _la==87:
                        self.state = 1158
                        self.attributeSpecifierSeq()


                    self.state = 1162
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                    if la_ == 1:
                        self.state = 1161
                        self.nestedNameSpecifier(0)


                    self.state = 1164
                    self.match(CPP14Parser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 1165
                    self.simpleTemplateId()
                    pass

                elif la_ == 3:
                    self.state = 1166
                    self.nestedNameSpecifier(0)
                    self.state = 1168
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==68:
                        self.state = 1167
                        self.match(CPP14Parser.Template)


                    self.state = 1170
                    self.simpleTemplateId()
                    pass


                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1174
                self.match(CPP14Parser.Enum)
                self.state = 1176
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                if la_ == 1:
                    self.state = 1175
                    self.nestedNameSpecifier(0)


                self.state = 1178
                self.match(CPP14Parser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumName" ):
                listener.enterEnumName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumName" ):
                listener.exitEnumName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumName" ):
                return visitor.visitEnumName(self)
            else:
                return visitor.visitChildren(self)




    def enumName(self):

        localctx = CPP14Parser.EnumNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_enumName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1181
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumHead(self):
            return self.getTypedRuleContext(CPP14Parser.EnumHeadContext,0)


        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def enumeratorList(self):
            return self.getTypedRuleContext(CPP14Parser.EnumeratorListContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumSpecifier" ):
                listener.enterEnumSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumSpecifier" ):
                listener.exitEnumSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumSpecifier" ):
                return visitor.visitEnumSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def enumSpecifier(self):

        localctx = CPP14Parser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1183
            self.enumHead()
            self.state = 1184
            self.match(CPP14Parser.LeftBrace)
            self.state = 1189
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==132:
                self.state = 1185
                self.enumeratorList()
                self.state = 1187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==122:
                    self.state = 1186
                    self.match(CPP14Parser.Comma)




            self.state = 1191
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumkey(self):
            return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def enumbase(self):
            return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumHead" ):
                listener.enterEnumHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumHead" ):
                listener.exitEnumHead(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumHead" ):
                return visitor.visitEnumHead(self)
            else:
                return visitor.visitChildren(self)




    def enumHead(self):

        localctx = CPP14Parser.EnumHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_enumHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1193
            self.enumkey()
            self.state = 1195
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1194
                self.attributeSpecifierSeq()


            self.state = 1201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26 or _la==127 or _la==132:
                self.state = 1198
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 1197
                    self.nestedNameSpecifier(0)


                self.state = 1200
                self.match(CPP14Parser.Identifier)


            self.state = 1204
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1203
                self.enumbase()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OpaqueEnumDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumkey(self):
            return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def enumbase(self):
            return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_opaqueEnumDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOpaqueEnumDeclaration" ):
                listener.enterOpaqueEnumDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOpaqueEnumDeclaration" ):
                listener.exitOpaqueEnumDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOpaqueEnumDeclaration" ):
                return visitor.visitOpaqueEnumDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def opaqueEnumDeclaration(self):

        localctx = CPP14Parser.OpaqueEnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_opaqueEnumDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1206
            self.enumkey()
            self.state = 1208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1207
                self.attributeSpecifierSeq()


            self.state = 1210
            self.match(CPP14Parser.Identifier)
            self.state = 1212
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1211
                self.enumbase()


            self.state = 1214
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumkeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Enum(self):
            return self.getToken(CPP14Parser.Enum, 0)

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Struct(self):
            return self.getToken(CPP14Parser.Struct, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumkey

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumkey" ):
                listener.enterEnumkey(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumkey" ):
                listener.exitEnumkey(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumkey" ):
                return visitor.visitEnumkey(self)
            else:
                return visitor.visitChildren(self)




    def enumkey(self):

        localctx = CPP14Parser.EnumkeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_enumkey)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1216
            self.match(CPP14Parser.Enum)
            self.state = 1218
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==66:
                self.state = 1217
                _la = self._input.LA(1)
                if not(_la==21 or _la==66):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumbaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumbase

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumbase" ):
                listener.enterEnumbase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumbase" ):
                listener.exitEnumbase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumbase" ):
                return visitor.visitEnumbase(self)
            else:
                return visitor.visitChildren(self)




    def enumbase(self):

        localctx = CPP14Parser.EnumbaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_enumbase)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1220
            self.match(CPP14Parser.Colon)
            self.state = 1221
            self.typeSpecifierSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumeratorDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.EnumeratorDefinitionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.EnumeratorDefinitionContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumeratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumeratorList" ):
                listener.enterEnumeratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumeratorList" ):
                listener.exitEnumeratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumeratorList" ):
                return visitor.visitEnumeratorList(self)
            else:
                return visitor.visitChildren(self)




    def enumeratorList(self):

        localctx = CPP14Parser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_enumeratorList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1223
            self.enumeratorDefinition()
            self.state = 1228
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,140,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1224
                    self.match(CPP14Parser.Comma)
                    self.state = 1225
                    self.enumeratorDefinition() 
                self.state = 1230
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,140,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumerator(self):
            return self.getTypedRuleContext(CPP14Parser.EnumeratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumeratorDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumeratorDefinition" ):
                listener.enterEnumeratorDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumeratorDefinition" ):
                listener.exitEnumeratorDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumeratorDefinition" ):
                return visitor.visitEnumeratorDefinition(self)
            else:
                return visitor.visitChildren(self)




    def enumeratorDefinition(self):

        localctx = CPP14Parser.EnumeratorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_enumeratorDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1231
            self.enumerator()
            self.state = 1234
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==101:
                self.state = 1232
                self.match(CPP14Parser.Assign)
                self.state = 1233
                self.constantExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumerator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumerator" ):
                listener.enterEnumerator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumerator" ):
                listener.exitEnumerator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumerator" ):
                return visitor.visitEnumerator(self)
            else:
                return visitor.visitChildren(self)




    def enumerator(self):

        localctx = CPP14Parser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_enumerator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1236
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def originalNamespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.OriginalNamespaceNameContext,0)


        def namespaceAlias(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceAliasContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceName" ):
                listener.enterNamespaceName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceName" ):
                listener.exitNamespaceName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceName" ):
                return visitor.visitNamespaceName(self)
            else:
                return visitor.visitChildren(self)




    def namespaceName(self):

        localctx = CPP14Parser.NamespaceNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_namespaceName)
        try:
            self.state = 1240
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1238
                self.originalNamespaceName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1239
                self.namespaceAlias()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OriginalNamespaceNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_originalNamespaceName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOriginalNamespaceName" ):
                listener.enterOriginalNamespaceName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOriginalNamespaceName" ):
                listener.exitOriginalNamespaceName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOriginalNamespaceName" ):
                return visitor.visitOriginalNamespaceName(self)
            else:
                return visitor.visitChildren(self)




    def originalNamespaceName(self):

        localctx = CPP14Parser.OriginalNamespaceNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_originalNamespaceName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1242
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.namespaceBody = None # DeclarationseqContext

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def Inline(self):
            return self.getToken(CPP14Parser.Inline, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def originalNamespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.OriginalNamespaceNameContext,0)


        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceDefinition" ):
                listener.enterNamespaceDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceDefinition" ):
                listener.exitNamespaceDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceDefinition" ):
                return visitor.visitNamespaceDefinition(self)
            else:
                return visitor.visitChildren(self)




    def namespaceDefinition(self):

        localctx = CPP14Parser.NamespaceDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_namespaceDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1245
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44:
                self.state = 1244
                self.match(CPP14Parser.Inline)


            self.state = 1247
            self.match(CPP14Parser.Namespace)
            self.state = 1250
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1248
                self.match(CPP14Parser.Identifier)

            elif la_ == 2:
                self.state = 1249
                self.originalNamespaceName()


            self.state = 1252
            self.match(CPP14Parser.LeftBrace)
            self.state = 1254
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543754443169808157) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 459384754220313597) != 0:
                self.state = 1253
                localctx.namespaceBody = self.declarationseq()


            self.state = 1256
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceAliasContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceAlias

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceAlias" ):
                listener.enterNamespaceAlias(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceAlias" ):
                listener.exitNamespaceAlias(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceAlias" ):
                return visitor.visitNamespaceAlias(self)
            else:
                return visitor.visitChildren(self)




    def namespaceAlias(self):

        localctx = CPP14Parser.NamespaceAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_namespaceAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1258
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceAliasDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def qualifiednamespacespecifier(self):
            return self.getTypedRuleContext(CPP14Parser.QualifiednamespacespecifierContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceAliasDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceAliasDefinition" ):
                listener.enterNamespaceAliasDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceAliasDefinition" ):
                listener.exitNamespaceAliasDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceAliasDefinition" ):
                return visitor.visitNamespaceAliasDefinition(self)
            else:
                return visitor.visitChildren(self)




    def namespaceAliasDefinition(self):

        localctx = CPP14Parser.NamespaceAliasDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_namespaceAliasDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1260
            self.match(CPP14Parser.Namespace)
            self.state = 1261
            self.match(CPP14Parser.Identifier)
            self.state = 1262
            self.match(CPP14Parser.Assign)
            self.state = 1263
            self.qualifiednamespacespecifier()
            self.state = 1264
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiednamespacespecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_qualifiednamespacespecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiednamespacespecifier" ):
                listener.enterQualifiednamespacespecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiednamespacespecifier" ):
                listener.exitQualifiednamespacespecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiednamespacespecifier" ):
                return visitor.visitQualifiednamespacespecifier(self)
            else:
                return visitor.visitChildren(self)




    def qualifiednamespacespecifier(self):

        localctx = CPP14Parser.QualifiednamespacespecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_qualifiednamespacespecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.state = 1266
                self.nestedNameSpecifier(0)


            self.state = 1269
            self.namespaceName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_usingDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingDeclaration" ):
                listener.enterUsingDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingDeclaration" ):
                listener.exitUsingDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingDeclaration" ):
                return visitor.visitUsingDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def usingDeclaration(self):

        localctx = CPP14Parser.UsingDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_usingDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1271
            self.match(CPP14Parser.Using)
            self.state = 1277
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.state = 1273
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 1272
                    self.match(CPP14Parser.Typename_)


                self.state = 1275
                self.nestedNameSpecifier(0)
                pass

            elif la_ == 2:
                self.state = 1276
                self.match(CPP14Parser.Doublecolon)
                pass


            self.state = 1279
            self.unqualifiedId()
            self.state = 1280
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_usingDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingDirective" ):
                listener.enterUsingDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingDirective" ):
                listener.exitUsingDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingDirective" ):
                return visitor.visitUsingDirective(self)
            else:
                return visitor.visitChildren(self)




    def usingDirective(self):

        localctx = CPP14Parser.UsingDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_usingDirective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1282
                self.attributeSpecifierSeq()


            self.state = 1285
            self.match(CPP14Parser.Using)
            self.state = 1286
            self.match(CPP14Parser.Namespace)
            self.state = 1288
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
            if la_ == 1:
                self.state = 1287
                self.nestedNameSpecifier(0)


            self.state = 1290
            self.namespaceName()
            self.state = 1291
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AsmDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Asm(self):
            return self.getToken(CPP14Parser.Asm, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_asmDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsmDefinition" ):
                listener.enterAsmDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsmDefinition" ):
                listener.exitAsmDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsmDefinition" ):
                return visitor.visitAsmDefinition(self)
            else:
                return visitor.visitChildren(self)




    def asmDefinition(self):

        localctx = CPP14Parser.AsmDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_asmDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1293
            self.match(CPP14Parser.Asm)
            self.state = 1294
            self.match(CPP14Parser.LeftParen)
            self.state = 1295
            self.match(CPP14Parser.StringLiteral)
            self.state = 1296
            self.match(CPP14Parser.RightParen)
            self.state = 1297
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LinkageSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_linkageSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLinkageSpecification" ):
                listener.enterLinkageSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLinkageSpecification" ):
                listener.exitLinkageSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLinkageSpecification" ):
                return visitor.visitLinkageSpecification(self)
            else:
                return visitor.visitChildren(self)




    def linkageSpecification(self):

        localctx = CPP14Parser.LinkageSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_linkageSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1299
            self.match(CPP14Parser.Extern)
            self.state = 1300
            self.match(CPP14Parser.StringLiteral)
            self.state = 1307
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89]:
                self.state = 1301
                self.match(CPP14Parser.LeftBrace)
                self.state = 1303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543754443169808157) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 459384754220313597) != 0:
                    self.state = 1302
                    self.declarationseq()


                self.state = 1305
                self.match(CPP14Parser.RightBrace)
                pass
            elif token in [10, 12, 13, 14, 18, 19, 20, 21, 22, 23, 26, 30, 33, 34, 36, 39, 41, 44, 45, 46, 47, 48, 52, 57, 60, 61, 63, 64, 66, 68, 70, 74, 76, 77, 78, 79, 80, 81, 82, 83, 85, 87, 93, 97, 99, 118, 127, 128, 131, 132]:
                self.state = 1306
                self.declaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AttributeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeSpecifierSeq" ):
                listener.enterAttributeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeSpecifierSeq" ):
                listener.exitAttributeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeSpecifierSeq" ):
                return visitor.visitAttributeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def attributeSpecifierSeq(self):

        localctx = CPP14Parser.AttributeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_attributeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1310 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1309
                    self.attributeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1312 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBracket)
            else:
                return self.getToken(CPP14Parser.LeftBracket, i)

        def RightBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBracket)
            else:
                return self.getToken(CPP14Parser.RightBracket, i)

        def attributeList(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeListContext,0)


        def alignmentspecifier(self):
            return self.getTypedRuleContext(CPP14Parser.AlignmentspecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeSpecifier" ):
                listener.enterAttributeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeSpecifier" ):
                listener.exitAttributeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeSpecifier" ):
                return visitor.visitAttributeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def attributeSpecifier(self):

        localctx = CPP14Parser.AttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_attributeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1322
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [87]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1314
                self.match(CPP14Parser.LeftBracket)
                self.state = 1315
                self.match(CPP14Parser.LeftBracket)
                self.state = 1317
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==132:
                    self.state = 1316
                    self.attributeList()


                self.state = 1319
                self.match(CPP14Parser.RightBracket)
                self.state = 1320
                self.match(CPP14Parser.RightBracket)
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1321
                self.alignmentspecifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlignmentspecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Alignas(self):
            return self.getToken(CPP14Parser.Alignas, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_alignmentspecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAlignmentspecifier" ):
                listener.enterAlignmentspecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAlignmentspecifier" ):
                listener.exitAlignmentspecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAlignmentspecifier" ):
                return visitor.visitAlignmentspecifier(self)
            else:
                return visitor.visitChildren(self)




    def alignmentspecifier(self):

        localctx = CPP14Parser.AlignmentspecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_alignmentspecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1324
            self.match(CPP14Parser.Alignas)
            self.state = 1325
            self.match(CPP14Parser.LeftParen)
            self.state = 1328
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.state = 1326
                self.theTypeId()
                pass

            elif la_ == 2:
                self.state = 1327
                self.constantExpression()
                pass


            self.state = 1331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1330
                self.match(CPP14Parser.Ellipsis)


            self.state = 1333
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AttributeContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeList" ):
                listener.enterAttributeList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeList" ):
                listener.exitAttributeList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeList" ):
                return visitor.visitAttributeList(self)
            else:
                return visitor.visitChildren(self)




    def attributeList(self):

        localctx = CPP14Parser.AttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_attributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1335
            self.attribute()
            self.state = 1340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1336
                self.match(CPP14Parser.Comma)
                self.state = 1337
                self.attribute()
                self.state = 1342
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1343
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def attributeNamespace(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeNamespaceContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def attributeArgumentClause(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeArgumentClauseContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attribute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute" ):
                listener.enterAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute" ):
                listener.exitAttribute(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttribute" ):
                return visitor.visitAttribute(self)
            else:
                return visitor.visitChildren(self)




    def attribute(self):

        localctx = CPP14Parser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1349
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1346
                self.attributeNamespace()
                self.state = 1347
                self.match(CPP14Parser.Doublecolon)


            self.state = 1351
            self.match(CPP14Parser.Identifier)
            self.state = 1353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==85:
                self.state = 1352
                self.attributeArgumentClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeNamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeNamespace

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeNamespace" ):
                listener.enterAttributeNamespace(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeNamespace" ):
                listener.exitAttributeNamespace(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeNamespace" ):
                return visitor.visitAttributeNamespace(self)
            else:
                return visitor.visitChildren(self)




    def attributeNamespace(self):

        localctx = CPP14Parser.AttributeNamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_attributeNamespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1355
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeArgumentClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def balancedTokenSeq(self):
            return self.getTypedRuleContext(CPP14Parser.BalancedTokenSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeArgumentClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeArgumentClause" ):
                listener.enterAttributeArgumentClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeArgumentClause" ):
                listener.exitAttributeArgumentClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeArgumentClause" ):
                return visitor.visitAttributeArgumentClause(self)
            else:
                return visitor.visitChildren(self)




    def attributeArgumentClause(self):

        localctx = CPP14Parser.AttributeArgumentClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_attributeArgumentClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1357
            self.match(CPP14Parser.LeftParen)
            self.state = 1359
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -88080385) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 524287) != 0:
                self.state = 1358
                self.balancedTokenSeq()


            self.state = 1361
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BalancedTokenSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def balancedtoken(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.BalancedtokenContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.BalancedtokenContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_balancedTokenSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBalancedTokenSeq" ):
                listener.enterBalancedTokenSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBalancedTokenSeq" ):
                listener.exitBalancedTokenSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBalancedTokenSeq" ):
                return visitor.visitBalancedTokenSeq(self)
            else:
                return visitor.visitChildren(self)




    def balancedTokenSeq(self):

        localctx = CPP14Parser.BalancedTokenSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_balancedTokenSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1364 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1363
                self.balancedtoken()
                self.state = 1366 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -88080385) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 524287) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BalancedtokenContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftParen)
            else:
                return self.getToken(CPP14Parser.LeftParen, i)

        def balancedTokenSeq(self):
            return self.getTypedRuleContext(CPP14Parser.BalancedTokenSeqContext,0)


        def RightParen(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightParen)
            else:
                return self.getToken(CPP14Parser.RightParen, i)

        def LeftBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBracket)
            else:
                return self.getToken(CPP14Parser.LeftBracket, i)

        def RightBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBracket)
            else:
                return self.getToken(CPP14Parser.RightBracket, i)

        def LeftBrace(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBrace)
            else:
                return self.getToken(CPP14Parser.LeftBrace, i)

        def RightBrace(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBrace)
            else:
                return self.getToken(CPP14Parser.RightBrace, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_balancedtoken

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBalancedtoken" ):
                listener.enterBalancedtoken(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBalancedtoken" ):
                listener.exitBalancedtoken(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBalancedtoken" ):
                return visitor.visitBalancedtoken(self)
            else:
                return visitor.visitChildren(self)




    def balancedtoken(self):

        localctx = CPP14Parser.BalancedtokenContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_balancedtoken)
        self._la = 0 # Token type
        try:
            self.state = 1385
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [85]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1368
                self.match(CPP14Parser.LeftParen)
                self.state = 1369
                self.balancedTokenSeq()
                self.state = 1370
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [87]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1372
                self.match(CPP14Parser.LeftBracket)
                self.state = 1373
                self.balancedTokenSeq()
                self.state = 1374
                self.match(CPP14Parser.RightBracket)
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1376
                self.match(CPP14Parser.LeftBrace)
                self.state = 1377
                self.balancedTokenSeq()
                self.state = 1378
                self.match(CPP14Parser.RightBrace)
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1381 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1380
                        _la = self._input.LA(1)
                        if _la <= 0 or (((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 63) != 0:
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1383 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,164,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InitDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InitDeclaratorContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initDeclaratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitDeclaratorList" ):
                listener.enterInitDeclaratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitDeclaratorList" ):
                listener.exitInitDeclaratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitDeclaratorList" ):
                return visitor.visitInitDeclaratorList(self)
            else:
                return visitor.visitChildren(self)




    def initDeclaratorList(self):

        localctx = CPP14Parser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1387
            self.initDeclarator()
            self.state = 1392
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1388
                self.match(CPP14Parser.Comma)
                self.state = 1389
                self.initDeclarator()
                self.state = 1394
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def initializer(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_initDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitDeclarator" ):
                listener.enterInitDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitDeclarator" ):
                listener.exitInitDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitDeclarator" ):
                return visitor.visitInitDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def initDeclarator(self):

        localctx = CPP14Parser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1395
            self.declarator()
            self.state = 1397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 65553) != 0:
                self.state = 1396
                self.initializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerDeclaratorContext,0)


        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarator" ):
                listener.enterDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarator" ):
                listener.exitDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarator" ):
                return visitor.visitDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def declarator(self):

        localctx = CPP14Parser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_declarator)
        try:
            self.state = 1404
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1399
                self.pointerDeclarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1400
                self.noPointerDeclarator(0)
                self.state = 1401
                self.parametersAndQualifiers()
                self.state = 1402
                self.trailingReturnType()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def Const(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Const)
            else:
                return self.getToken(CPP14Parser.Const, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerDeclarator" ):
                listener.enterPointerDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerDeclarator" ):
                listener.exitPointerDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerDeclarator" ):
                return visitor.visitPointerDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def pointerDeclarator(self):

        localctx = CPP14Parser.PointerDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_pointerDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1412
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1406
                    self.pointerOperator()
                    self.state = 1408
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==22:
                        self.state = 1407
                        self.match(CPP14Parser.Const)

             
                self.state = 1414
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,self._ctx)

            self.state = 1415
            self.noPointerDeclarator(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declaratorid(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratoridContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def pointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerDeclaratorContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerDeclarator" ):
                listener.enterNoPointerDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerDeclarator" ):
                listener.exitNoPointerDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerDeclarator" ):
                return visitor.visitNoPointerDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 230
        self.enterRecursionRule(localctx, 230, self.RULE_noPointerDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1426
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [26, 52, 99, 127, 131, 132]:
                self.state = 1418
                self.declaratorid()
                self.state = 1420
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1419
                    self.attributeSpecifierSeq()


                pass
            elif token in [85]:
                self.state = 1422
                self.match(CPP14Parser.LeftParen)
                self.state = 1423
                self.pointerDeclarator()
                self.state = 1424
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1442
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,176,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerDeclarator)
                    self.state = 1428
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1438
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [85]:
                        self.state = 1429
                        self.parametersAndQualifiers()
                        pass
                    elif token in [87]:
                        self.state = 1430
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1432
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133137) != 0 or _la==132:
                            self.state = 1431
                            self.constantExpression()


                        self.state = 1434
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1436
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                        if la_ == 1:
                            self.state = 1435
                            self.attributeSpecifierSeq()


                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1444
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,176,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ParametersAndQualifiersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def parameterDeclarationClause(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationClauseContext,0)


        def cvqualifierseq(self):
            return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)


        def refqualifier(self):
            return self.getTypedRuleContext(CPP14Parser.RefqualifierContext,0)


        def exceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionSpecificationContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_parametersAndQualifiers

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParametersAndQualifiers" ):
                listener.enterParametersAndQualifiers(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParametersAndQualifiers" ):
                listener.exitParametersAndQualifiers(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParametersAndQualifiers" ):
                return visitor.visitParametersAndQualifiers(self)
            else:
                return visitor.visitChildren(self)




    def parametersAndQualifiers(self):

        localctx = CPP14Parser.ParametersAndQualifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_parametersAndQualifiers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1445
            self.match(CPP14Parser.LeftParen)
            self.state = 1447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1237504995584196377) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 297237575406461917) != 0:
                self.state = 1446
                self.parameterDeclarationClause()


            self.state = 1449
            self.match(CPP14Parser.RightParen)
            self.state = 1451
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 1450
                self.cvqualifierseq()


            self.state = 1454
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.state = 1453
                self.refqualifier()


            self.state = 1457
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1456
                self.exceptionSpecification()


            self.state = 1460
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1459
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingReturnTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def trailingTypeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierSeqContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingReturnType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingReturnType" ):
                listener.enterTrailingReturnType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingReturnType" ):
                listener.exitTrailingReturnType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingReturnType" ):
                return visitor.visitTrailingReturnType(self)
            else:
                return visitor.visitChildren(self)




    def trailingReturnType(self):

        localctx = CPP14Parser.TrailingReturnTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_trailingReturnType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1462
            self.match(CPP14Parser.Arrow)
            self.state = 1463
            self.trailingTypeSpecifierSeq()
            self.state = 1465
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.state = 1464
                self.abstractDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def cvqualifierseq(self):
            return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerOperator" ):
                listener.enterPointerOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerOperator" ):
                listener.exitPointerOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerOperator" ):
                return visitor.visitPointerOperator(self)
            else:
                return visitor.visitChildren(self)




    def pointerOperator(self):

        localctx = CPP14Parser.PointerOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_pointerOperator)
        self._la = 0 # Token type
        try:
            self.state = 1481
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [97, 118]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1467
                _la = self._input.LA(1)
                if not(_la==97 or _la==118):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1469
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                if la_ == 1:
                    self.state = 1468
                    self.attributeSpecifierSeq()


                pass
            elif token in [26, 93, 127, 132]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1472
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26 or _la==127 or _la==132:
                    self.state = 1471
                    self.nestedNameSpecifier(0)


                self.state = 1474
                self.match(CPP14Parser.Star)
                self.state = 1476
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 1475
                    self.attributeSpecifierSeq()


                self.state = 1479
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1478
                    self.cvqualifierseq()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CvqualifierseqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cvQualifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CvQualifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CvQualifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_cvqualifierseq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCvqualifierseq" ):
                listener.enterCvqualifierseq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCvqualifierseq" ):
                listener.exitCvqualifierseq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCvqualifierseq" ):
                return visitor.visitCvqualifierseq(self)
            else:
                return visitor.visitChildren(self)




    def cvqualifierseq(self):

        localctx = CPP14Parser.CvqualifierseqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_cvqualifierseq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1484 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1483
                    self.cvQualifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1486 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,188,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CvQualifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Const(self):
            return self.getToken(CPP14Parser.Const, 0)

        def Volatile(self):
            return self.getToken(CPP14Parser.Volatile, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_cvQualifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCvQualifier" ):
                listener.enterCvQualifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCvQualifier" ):
                listener.exitCvQualifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCvQualifier" ):
                return visitor.visitCvQualifier(self)
            else:
                return visitor.visitChildren(self)




    def cvQualifier(self):

        localctx = CPP14Parser.CvQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_cvQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1488
            _la = self._input.LA(1)
            if not(_la==22 or _la==82):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RefqualifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_refqualifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRefqualifier" ):
                listener.enterRefqualifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRefqualifier" ):
                listener.exitRefqualifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRefqualifier" ):
                return visitor.visitRefqualifier(self)
            else:
                return visitor.visitChildren(self)




    def refqualifier(self):

        localctx = CPP14Parser.RefqualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_refqualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1490
            _la = self._input.LA(1)
            if not(_la==97 or _la==118):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclaratoridContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_declaratorid

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclaratorid" ):
                listener.enterDeclaratorid(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclaratorid" ):
                listener.exitDeclaratorid(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclaratorid" ):
                return visitor.visitDeclaratorid(self)
            else:
                return visitor.visitChildren(self)




    def declaratorid(self):

        localctx = CPP14Parser.DeclaratoridContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_declaratorid)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1492
                self.match(CPP14Parser.Ellipsis)


            self.state = 1495
            self.idExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_theTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheTypeId" ):
                listener.enterTheTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheTypeId" ):
                listener.exitTheTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheTypeId" ):
                return visitor.visitTheTypeId(self)
            else:
                return visitor.visitChildren(self)




    def theTypeId(self):

        localctx = CPP14Parser.TheTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_theTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1497
            self.typeSpecifierSeq()
            self.state = 1499
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.state = 1498
                self.abstractDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerAbstractDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def noPointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,0)


        def abstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractPackDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_abstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbstractDeclarator" ):
                listener.enterAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbstractDeclarator" ):
                listener.exitAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAbstractDeclarator" ):
                return visitor.visitAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def abstractDeclarator(self):

        localctx = CPP14Parser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_abstractDeclarator)
        try:
            self.state = 1509
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1501
                self.pointerAbstractDeclarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1503
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
                if la_ == 1:
                    self.state = 1502
                    self.noPointerAbstractDeclarator(0)


                self.state = 1505
                self.parametersAndQualifiers()
                self.state = 1506
                self.trailingReturnType()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1508
                self.abstractPackDeclarator()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerAbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerAbstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerAbstractDeclarator" ):
                listener.enterPointerAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerAbstractDeclarator" ):
                listener.exitPointerAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerAbstractDeclarator" ):
                return visitor.visitPointerAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def pointerAbstractDeclarator(self):

        localctx = CPP14Parser.PointerAbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_pointerAbstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1520
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [85, 87]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1511
                self.noPointerAbstractDeclarator(0)
                pass
            elif token in [26, 93, 97, 118, 127, 132]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1513 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1512
                    self.pointerOperator()
                    self.state = 1515 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==26 or (((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & 566969237521) != 0):
                        break

                self.state = 1518
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
                if la_ == 1:
                    self.state = 1517
                    self.noPointerAbstractDeclarator(0)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerAbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def pointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerAbstractDeclaratorContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def noPointerAbstractDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.NoPointerAbstractDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerAbstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerAbstractDeclarator" ):
                listener.enterNoPointerAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerAbstractDeclarator" ):
                listener.exitNoPointerAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerAbstractDeclarator" ):
                return visitor.visitNoPointerAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerAbstractDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerAbstractDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 252
        self.enterRecursionRule(localctx, 252, self.RULE_noPointerAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1536
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1523
                self.parametersAndQualifiers()
                pass

            elif la_ == 2:
                self.state = 1524
                self.match(CPP14Parser.LeftBracket)
                self.state = 1526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133137) != 0 or _la==132:
                    self.state = 1525
                    self.constantExpression()


                self.state = 1528
                self.match(CPP14Parser.RightBracket)
                self.state = 1530
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                if la_ == 1:
                    self.state = 1529
                    self.attributeSpecifierSeq()


                pass

            elif la_ == 3:
                self.state = 1532
                self.match(CPP14Parser.LeftParen)
                self.state = 1533
                self.pointerAbstractDeclarator()
                self.state = 1534
                self.match(CPP14Parser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1553
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,202,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerAbstractDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerAbstractDeclarator)
                    self.state = 1538
                    if not self.precpred(self._ctx, 4):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                    self.state = 1549
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                    if la_ == 1:
                        self.state = 1539
                        self.parametersAndQualifiers()
                        pass

                    elif la_ == 2:
                        self.state = 1540
                        self.noPointerAbstractDeclarator(0)
                        self.state = 1541
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1543
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133137) != 0 or _la==132:
                            self.state = 1542
                            self.constantExpression()


                        self.state = 1545
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1547
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                        if la_ == 1:
                            self.state = 1546
                            self.attributeSpecifierSeq()


                        pass

             
                self.state = 1555
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,202,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class AbstractPackDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerAbstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractPackDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_abstractPackDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbstractPackDeclarator" ):
                listener.enterAbstractPackDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbstractPackDeclarator" ):
                listener.exitAbstractPackDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAbstractPackDeclarator" ):
                return visitor.visitAbstractPackDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def abstractPackDeclarator(self):

        localctx = CPP14Parser.AbstractPackDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_abstractPackDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==26 or (((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & 566969237521) != 0:
                self.state = 1556
                self.pointerOperator()
                self.state = 1561
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1562
            self.noPointerAbstractPackDeclarator(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerAbstractPackDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def noPointerAbstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractPackDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerAbstractPackDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerAbstractPackDeclarator" ):
                listener.enterNoPointerAbstractPackDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerAbstractPackDeclarator" ):
                listener.exitNoPointerAbstractPackDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerAbstractPackDeclarator" ):
                return visitor.visitNoPointerAbstractPackDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerAbstractPackDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerAbstractPackDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 256
        self.enterRecursionRule(localctx, 256, self.RULE_noPointerAbstractPackDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            self.match(CPP14Parser.Ellipsis)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1581
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerAbstractPackDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerAbstractPackDeclarator)
                    self.state = 1567
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1577
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [85]:
                        self.state = 1568
                        self.parametersAndQualifiers()
                        pass
                    elif token in [87]:
                        self.state = 1569
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1571
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133137) != 0 or _la==132:
                            self.state = 1570
                            self.constantExpression()


                        self.state = 1573
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1575
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                        if la_ == 1:
                            self.state = 1574
                            self.attributeSpecifierSeq()


                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1583
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,207,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ParameterDeclarationClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterDeclarationList(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationListContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclarationClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclarationClause" ):
                listener.enterParameterDeclarationClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclarationClause" ):
                listener.exitParameterDeclarationClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclarationClause" ):
                return visitor.visitParameterDeclarationClause(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclarationClause(self):

        localctx = CPP14Parser.ParameterDeclarationClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_parameterDeclarationClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1584
            self.parameterDeclarationList()
            self.state = 1589
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==122 or _la==131:
                self.state = 1586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==122:
                    self.state = 1585
                    self.match(CPP14Parser.Comma)


                self.state = 1588
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ParameterDeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclarationList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclarationList" ):
                listener.enterParameterDeclarationList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclarationList" ):
                listener.exitParameterDeclarationList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclarationList" ):
                return visitor.visitParameterDeclarationList(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclarationList(self):

        localctx = CPP14Parser.ParameterDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_parameterDeclarationList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1591
            self.parameterDeclaration()
            self.state = 1596
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,210,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1592
                    self.match(CPP14Parser.Comma)
                    self.state = 1593
                    self.parameterDeclaration() 
                self.state = 1598
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,210,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclaration" ):
                listener.enterParameterDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclaration" ):
                listener.exitParameterDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclaration" ):
                return visitor.visitParameterDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclaration(self):

        localctx = CPP14Parser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_parameterDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1600
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1599
                self.attributeSpecifierSeq()


            self.state = 1602
            self.declSpecifierSeq()

            self.state = 1607
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.state = 1603
                self.declarator()
                pass

            elif la_ == 2:
                self.state = 1605
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1604
                    self.abstractDeclarator()


                pass


            self.state = 1611
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==101:
                self.state = 1609
                self.match(CPP14Parser.Assign)
                self.state = 1610
                self.initializerClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def functionBody(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionBodyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def virtualSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_functionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionDefinition" ):
                listener.enterFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionDefinition" ):
                listener.exitFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDefinition" ):
                return visitor.visitFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def functionDefinition(self):

        localctx = CPP14Parser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1614
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1613
                self.attributeSpecifierSeq()


            self.state = 1617
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
            if la_ == 1:
                self.state = 1616
                self.declSpecifierSeq()


            self.state = 1619
            self.declarator()
            self.state = 1621
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38 or _la==53:
                self.state = 1620
                self.virtualSpecifierSeq()


            self.state = 1623
            self.functionBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionBodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def constructorInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ConstructorInitializerContext,0)


        def functionTryBlock(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionTryBlockContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Default(self):
            return self.getToken(CPP14Parser.Default, 0)

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_functionBody

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionBody" ):
                listener.enterFunctionBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionBody" ):
                listener.exitFunctionBody(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionBody" ):
                return visitor.visitFunctionBody(self)
            else:
                return visitor.visitChildren(self)




    def functionBody(self):

        localctx = CPP14Parser.FunctionBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_functionBody)
        self._la = 0 # Token type
        try:
            self.state = 1633
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 126]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1626
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1625
                    self.constructorInitializer()


                self.state = 1628
                self.compoundStatement()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1629
                self.functionTryBlock()
                pass
            elif token in [101]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1630
                self.match(CPP14Parser.Assign)
                self.state = 1631
                _la = self._input.LA(1)
                if not(_la==27 or _la==28):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1632
                self.match(CPP14Parser.Semi)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def braceOrEqualInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.BraceOrEqualInitializerContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializer" ):
                listener.enterInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializer" ):
                listener.exitInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializer" ):
                return visitor.visitInitializer(self)
            else:
                return visitor.visitChildren(self)




    def initializer(self):

        localctx = CPP14Parser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_initializer)
        try:
            self.state = 1640
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 101]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1635
                self.braceOrEqualInitializer()
                pass
            elif token in [85]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1636
                self.match(CPP14Parser.LeftParen)
                self.state = 1637
                self.expressionList()
                self.state = 1638
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BraceOrEqualInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_braceOrEqualInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBraceOrEqualInitializer" ):
                listener.enterBraceOrEqualInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBraceOrEqualInitializer" ):
                listener.exitBraceOrEqualInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBraceOrEqualInitializer" ):
                return visitor.visitBraceOrEqualInitializer(self)
            else:
                return visitor.visitChildren(self)




    def braceOrEqualInitializer(self):

        localctx = CPP14Parser.BraceOrEqualInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_braceOrEqualInitializer)
        try:
            self.state = 1645
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [101]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1642
                self.match(CPP14Parser.Assign)
                self.state = 1643
                self.initializerClause()
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1644
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_initializerClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializerClause" ):
                listener.enterInitializerClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializerClause" ):
                listener.exitInitializerClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializerClause" ):
                return visitor.visitInitializerClause(self)
            else:
                return visitor.visitChildren(self)




    def initializerClause(self):

        localctx = CPP14Parser.InitializerClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_initializerClause)
        try:
            self.state = 1649
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 11, 13, 14, 18, 19, 20, 24, 26, 28, 30, 31, 39, 45, 46, 49, 50, 52, 58, 60, 61, 62, 65, 69, 71, 75, 76, 78, 81, 83, 85, 87, 91, 92, 93, 97, 98, 99, 100, 120, 121, 127, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1647
                self.assignmentExpression()
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1648
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initializerClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InitializerClauseContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initializerList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializerList" ):
                listener.enterInitializerList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializerList" ):
                listener.exitInitializerList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializerList" ):
                return visitor.visitInitializerList(self)
            else:
                return visitor.visitChildren(self)




    def initializerList(self):

        localctx = CPP14Parser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1651
            self.initializerClause()
            self.state = 1653
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1652
                self.match(CPP14Parser.Ellipsis)


            self.state = 1662
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,225,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1655
                    self.match(CPP14Parser.Comma)
                    self.state = 1656
                    self.initializerClause()
                    self.state = 1658
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1657
                        self.match(CPP14Parser.Ellipsis)

             
                self.state = 1664
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,225,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BracedInitListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def initializerList(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerListContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_bracedInitList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBracedInitList" ):
                listener.enterBracedInitList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBracedInitList" ):
                listener.exitBracedInitList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBracedInitList" ):
                return visitor.visitBracedInitList(self)
            else:
                return visitor.visitChildren(self)




    def bracedInitList(self):

        localctx = CPP14Parser.BracedInitListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_bracedInitList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1665
            self.match(CPP14Parser.LeftBrace)
            self.state = 1670
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474400910417) != 0 or _la==132:
                self.state = 1666
                self.initializerList()
                self.state = 1668
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==122:
                    self.state = 1667
                    self.match(CPP14Parser.Comma)




            self.state = 1672
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_className

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassName" ):
                listener.enterClassName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassName" ):
                listener.exitClassName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassName" ):
                return visitor.visitClassName(self)
            else:
                return visitor.visitChildren(self)




    def className(self):

        localctx = CPP14Parser.ClassNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_className)
        try:
            self.state = 1676
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1674
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1675
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classHead(self):
            return self.getTypedRuleContext(CPP14Parser.ClassHeadContext,0)


        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def memberSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.MemberSpecificationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassSpecifier" ):
                listener.enterClassSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassSpecifier" ):
                listener.exitClassSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassSpecifier" ):
                return visitor.visitClassSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def classSpecifier(self):

        localctx = CPP14Parser.ClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_classSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1678
            self.classHead()
            self.state = 1679
            self.match(CPP14Parser.LeftBrace)
            self.state = 1681
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543877313594212121) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 463888353847684093) != 0:
                self.state = 1680
                self.memberSpecification()


            self.state = 1683
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classKey(self):
            return self.getTypedRuleContext(CPP14Parser.ClassKeyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def classHeadName(self):
            return self.getTypedRuleContext(CPP14Parser.ClassHeadNameContext,0)


        def baseClause(self):
            return self.getTypedRuleContext(CPP14Parser.BaseClauseContext,0)


        def classVirtSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ClassVirtSpecifierContext,0)


        def Union(self):
            return self.getToken(CPP14Parser.Union, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassHead" ):
                listener.enterClassHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassHead" ):
                listener.exitClassHead(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassHead" ):
                return visitor.visitClassHead(self)
            else:
                return visitor.visitChildren(self)




    def classHead(self):

        localctx = CPP14Parser.ClassHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_classHead)
        self._la = 0 # Token type
        try:
            self.state = 1708
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [21, 66]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1685
                self.classKey()
                self.state = 1687
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10 or _la==87:
                    self.state = 1686
                    self.attributeSpecifierSeq()


                self.state = 1693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26 or _la==127 or _la==132:
                    self.state = 1689
                    self.classHeadName()
                    self.state = 1691
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==38:
                        self.state = 1690
                        self.classVirtSpecifier()




                self.state = 1696
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 1695
                    self.baseClause()


                pass
            elif token in [77]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1698
                self.match(CPP14Parser.Union)
                self.state = 1700
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10 or _la==87:
                    self.state = 1699
                    self.attributeSpecifierSeq()


                self.state = 1706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26 or _la==127 or _la==132:
                    self.state = 1702
                    self.classHeadName()
                    self.state = 1704
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==38:
                        self.state = 1703
                        self.classVirtSpecifier()




                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassHeadNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classHeadName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassHeadName" ):
                listener.enterClassHeadName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassHeadName" ):
                listener.exitClassHeadName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassHeadName" ):
                return visitor.visitClassHeadName(self)
            else:
                return visitor.visitChildren(self)




    def classHeadName(self):

        localctx = CPP14Parser.ClassHeadNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_classHeadName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1711
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.state = 1710
                self.nestedNameSpecifier(0)


            self.state = 1713
            self.className()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassVirtSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Final(self):
            return self.getToken(CPP14Parser.Final, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classVirtSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassVirtSpecifier" ):
                listener.enterClassVirtSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassVirtSpecifier" ):
                listener.exitClassVirtSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassVirtSpecifier" ):
                return visitor.visitClassVirtSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def classVirtSpecifier(self):

        localctx = CPP14Parser.ClassVirtSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_classVirtSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1715
            self.match(CPP14Parser.Final)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassKeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Struct(self):
            return self.getToken(CPP14Parser.Struct, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classKey

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassKey" ):
                listener.enterClassKey(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassKey" ):
                listener.exitClassKey(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassKey" ):
                return visitor.visitClassKey(self)
            else:
                return visitor.visitChildren(self)




    def classKey(self):

        localctx = CPP14Parser.ClassKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_classKey)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1717
            _la = self._input.LA(1)
            if not(_la==21 or _la==66):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memberdeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemberdeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemberdeclarationContext,i)


        def accessSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AccessSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AccessSpecifierContext,i)


        def Colon(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Colon)
            else:
                return self.getToken(CPP14Parser.Colon, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memberSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberSpecification" ):
                listener.enterMemberSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberSpecification" ):
                listener.exitMemberSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberSpecification" ):
                return visitor.visitMemberSpecification(self)
            else:
                return visitor.visitChildren(self)




    def memberSpecification(self):

        localctx = CPP14Parser.MemberSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_memberSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1723 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1723
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [10, 13, 14, 18, 19, 20, 21, 22, 23, 26, 30, 33, 34, 36, 39, 41, 44, 45, 46, 47, 52, 57, 60, 61, 63, 64, 66, 68, 70, 74, 76, 77, 78, 79, 80, 81, 82, 83, 85, 87, 93, 97, 99, 118, 126, 127, 128, 131, 132]:
                    self.state = 1719
                    self.memberdeclaration()
                    pass
                elif token in [54, 55, 56]:
                    self.state = 1720
                    self.accessSpecifier()
                    self.state = 1721
                    self.match(CPP14Parser.Colon)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1725 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & 1543877313594212121) != 0 or (((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 463888353847684093) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberdeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def memberDeclaratorList(self):
            return self.getTypedRuleContext(CPP14Parser.MemberDeclaratorListContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionDefinitionContext,0)


        def usingDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDeclarationContext,0)


        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.StaticAssertDeclarationContext,0)


        def templateDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateDeclarationContext,0)


        def aliasDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AliasDeclarationContext,0)


        def emptyDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.EmptyDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memberdeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberdeclaration" ):
                listener.enterMemberdeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberdeclaration" ):
                listener.exitMemberdeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberdeclaration" ):
                return visitor.visitMemberdeclaration(self)
            else:
                return visitor.visitChildren(self)




    def memberdeclaration(self):

        localctx = CPP14Parser.MemberdeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_memberdeclaration)
        self._la = 0 # Token type
        try:
            self.state = 1743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,244,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1728
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
                if la_ == 1:
                    self.state = 1727
                    self.attributeSpecifierSeq()


                self.state = 1731
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
                if la_ == 1:
                    self.state = 1730
                    self.declSpecifierSeq()


                self.state = 1734
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 4503599694480384) != 0 or (((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 217711892254981) != 0:
                    self.state = 1733
                    self.memberDeclaratorList()


                self.state = 1736
                self.match(CPP14Parser.Semi)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1737
                self.functionDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1738
                self.usingDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1739
                self.staticAssertDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1740
                self.templateDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1741
                self.aliasDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1742
                self.emptyDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memberDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemberDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemberDeclaratorContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memberDeclaratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberDeclaratorList" ):
                listener.enterMemberDeclaratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberDeclaratorList" ):
                listener.exitMemberDeclaratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberDeclaratorList" ):
                return visitor.visitMemberDeclaratorList(self)
            else:
                return visitor.visitChildren(self)




    def memberDeclaratorList(self):

        localctx = CPP14Parser.MemberDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_memberDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1745
            self.memberDeclarator()
            self.state = 1750
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1746
                self.match(CPP14Parser.Comma)
                self.state = 1747
                self.memberDeclarator()
                self.state = 1752
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def virtualSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierSeqContext,0)


        def pureSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.PureSpecifierContext,0)


        def braceOrEqualInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.BraceOrEqualInitializerContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memberDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberDeclarator" ):
                listener.enterMemberDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberDeclarator" ):
                listener.exitMemberDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberDeclarator" ):
                return visitor.visitMemberDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def memberDeclarator(self):

        localctx = CPP14Parser.MemberDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_memberDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1773
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1753
                self.declarator()
                self.state = 1763
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
                if la_ == 1:
                    self.state = 1755
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==38 or _la==53:
                        self.state = 1754
                        self.virtualSpecifierSeq()


                    self.state = 1758
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==101:
                        self.state = 1757
                        self.pureSpecifier()


                    pass

                elif la_ == 2:
                    self.state = 1761
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==89 or _la==101:
                        self.state = 1760
                        self.braceOrEqualInitializer()


                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1766
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==132:
                    self.state = 1765
                    self.match(CPP14Parser.Identifier)


                self.state = 1769
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10 or _la==87:
                    self.state = 1768
                    self.attributeSpecifierSeq()


                self.state = 1771
                self.match(CPP14Parser.Colon)
                self.state = 1772
                self.constantExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VirtualSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def virtualSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.VirtualSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_virtualSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtualSpecifierSeq" ):
                listener.enterVirtualSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtualSpecifierSeq" ):
                listener.exitVirtualSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVirtualSpecifierSeq" ):
                return visitor.visitVirtualSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def virtualSpecifierSeq(self):

        localctx = CPP14Parser.VirtualSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_virtualSpecifierSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1776 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1775
                self.virtualSpecifier()
                self.state = 1778 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==38 or _la==53):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VirtualSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Override(self):
            return self.getToken(CPP14Parser.Override, 0)

        def Final(self):
            return self.getToken(CPP14Parser.Final, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_virtualSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtualSpecifier" ):
                listener.enterVirtualSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtualSpecifier" ):
                listener.exitVirtualSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVirtualSpecifier" ):
                return visitor.visitVirtualSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def virtualSpecifier(self):

        localctx = CPP14Parser.VirtualSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_virtualSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1780
            _la = self._input.LA(1)
            if not(_la==38 or _la==53):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PureSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.val = None # Token

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def OctalLiteral(self):
            return self.getToken(CPP14Parser.OctalLiteral, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pureSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPureSpecifier" ):
                listener.enterPureSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPureSpecifier" ):
                listener.exitPureSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPureSpecifier" ):
                return visitor.visitPureSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def pureSpecifier(self):

        localctx = CPP14Parser.PureSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_pureSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1782
            self.match(CPP14Parser.Assign)
            self.state = 1783
            localctx.val = self.match(CPP14Parser.OctalLiteral)
            #if((None if localctx.val is None else localctx.val.text).compareTo("0")!=0) throw new InputMismatchException(this);
            		
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def baseSpecifierList(self):
            return self.getTypedRuleContext(CPP14Parser.BaseSpecifierListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseClause" ):
                listener.enterBaseClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseClause" ):
                listener.exitBaseClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseClause" ):
                return visitor.visitBaseClause(self)
            else:
                return visitor.visitChildren(self)




    def baseClause(self):

        localctx = CPP14Parser.BaseClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_baseClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1786
            self.match(CPP14Parser.Colon)
            self.state = 1787
            self.baseSpecifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseSpecifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def baseSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.BaseSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.BaseSpecifierContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_baseSpecifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseSpecifierList" ):
                listener.enterBaseSpecifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseSpecifierList" ):
                listener.exitBaseSpecifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseSpecifierList" ):
                return visitor.visitBaseSpecifierList(self)
            else:
                return visitor.visitChildren(self)




    def baseSpecifierList(self):

        localctx = CPP14Parser.BaseSpecifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_baseSpecifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1789
            self.baseSpecifier()
            self.state = 1791
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1790
                self.match(CPP14Parser.Ellipsis)


            self.state = 1800
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1793
                self.match(CPP14Parser.Comma)
                self.state = 1794
                self.baseSpecifier()
                self.state = 1796
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1795
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1802
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def baseTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.BaseTypeSpecifierContext,0)


        def Virtual(self):
            return self.getToken(CPP14Parser.Virtual, 0)

        def accessSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.AccessSpecifierContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseSpecifier" ):
                listener.enterBaseSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseSpecifier" ):
                listener.exitBaseSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseSpecifier" ):
                return visitor.visitBaseSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def baseSpecifier(self):

        localctx = CPP14Parser.BaseSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_baseSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1804
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10 or _la==87:
                self.state = 1803
                self.attributeSpecifierSeq()


            self.state = 1818
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [26, 127, 132]:
                self.state = 1806
                self.baseTypeSpecifier()
                pass
            elif token in [80]:
                self.state = 1807
                self.match(CPP14Parser.Virtual)
                self.state = 1809
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 126100789566373888) != 0:
                    self.state = 1808
                    self.accessSpecifier()


                self.state = 1811
                self.baseTypeSpecifier()
                pass
            elif token in [54, 55, 56]:
                self.state = 1812
                self.accessSpecifier()
                self.state = 1814
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==80:
                    self.state = 1813
                    self.match(CPP14Parser.Virtual)


                self.state = 1816
                self.baseTypeSpecifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassOrDeclTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classOrDeclType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassOrDeclType" ):
                listener.enterClassOrDeclType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassOrDeclType" ):
                listener.exitClassOrDeclType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassOrDeclType" ):
                return visitor.visitClassOrDeclType(self)
            else:
                return visitor.visitChildren(self)




    def classOrDeclType(self):

        localctx = CPP14Parser.ClassOrDeclTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_classOrDeclType)
        try:
            self.state = 1825
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1821
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1820
                    self.nestedNameSpecifier(0)


                self.state = 1823
                self.className()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1824
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrDeclType(self):
            return self.getTypedRuleContext(CPP14Parser.ClassOrDeclTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseTypeSpecifier" ):
                listener.enterBaseTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseTypeSpecifier" ):
                listener.exitBaseTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseTypeSpecifier" ):
                return visitor.visitBaseTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def baseTypeSpecifier(self):

        localctx = CPP14Parser.BaseTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_baseTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1827
            self.classOrDeclType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AccessSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Private(self):
            return self.getToken(CPP14Parser.Private, 0)

        def Protected(self):
            return self.getToken(CPP14Parser.Protected, 0)

        def Public(self):
            return self.getToken(CPP14Parser.Public, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_accessSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAccessSpecifier" ):
                listener.enterAccessSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAccessSpecifier" ):
                listener.exitAccessSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAccessSpecifier" ):
                return visitor.visitAccessSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def accessSpecifier(self):

        localctx = CPP14Parser.AccessSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_accessSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 126100789566373888) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionFunctionIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def conversionTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionTypeIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionFunctionId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionFunctionId" ):
                listener.enterConversionFunctionId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionFunctionId" ):
                listener.exitConversionFunctionId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionFunctionId" ):
                return visitor.visitConversionFunctionId(self)
            else:
                return visitor.visitChildren(self)




    def conversionFunctionId(self):

        localctx = CPP14Parser.ConversionFunctionIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_conversionFunctionId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1831
            self.match(CPP14Parser.Operator)
            self.state = 1832
            self.conversionTypeId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def conversionDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionTypeId" ):
                listener.enterConversionTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionTypeId" ):
                listener.exitConversionTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionTypeId" ):
                return visitor.visitConversionTypeId(self)
            else:
                return visitor.visitChildren(self)




    def conversionTypeId(self):

        localctx = CPP14Parser.ConversionTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_conversionTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1834
            self.typeSpecifierSeq()
            self.state = 1836
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
            if la_ == 1:
                self.state = 1835
                self.conversionDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerOperator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,0)


        def conversionDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionDeclarator" ):
                listener.enterConversionDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionDeclarator" ):
                listener.exitConversionDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionDeclarator" ):
                return visitor.visitConversionDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def conversionDeclarator(self):

        localctx = CPP14Parser.ConversionDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_conversionDeclarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1838
            self.pointerOperator()
            self.state = 1840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,264,self._ctx)
            if la_ == 1:
                self.state = 1839
                self.conversionDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def memInitializerList(self):
            return self.getTypedRuleContext(CPP14Parser.MemInitializerListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_constructorInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructorInitializer" ):
                listener.enterConstructorInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructorInitializer" ):
                listener.exitConstructorInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstructorInitializer" ):
                return visitor.visitConstructorInitializer(self)
            else:
                return visitor.visitChildren(self)




    def constructorInitializer(self):

        localctx = CPP14Parser.ConstructorInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_constructorInitializer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1842
            self.match(CPP14Parser.Colon)
            self.state = 1843
            self.memInitializerList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemInitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemInitializerContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemInitializerContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memInitializerList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemInitializerList" ):
                listener.enterMemInitializerList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemInitializerList" ):
                listener.exitMemInitializerList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemInitializerList" ):
                return visitor.visitMemInitializerList(self)
            else:
                return visitor.visitChildren(self)




    def memInitializerList(self):

        localctx = CPP14Parser.MemInitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_memInitializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1845
            self.memInitializer()
            self.state = 1847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1846
                self.match(CPP14Parser.Ellipsis)


            self.state = 1856
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1849
                self.match(CPP14Parser.Comma)
                self.state = 1850
                self.memInitializer()
                self.state = 1852
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1851
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1858
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def meminitializerid(self):
            return self.getTypedRuleContext(CPP14Parser.MeminitializeridContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemInitializer" ):
                listener.enterMemInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemInitializer" ):
                listener.exitMemInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemInitializer" ):
                return visitor.visitMemInitializer(self)
            else:
                return visitor.visitChildren(self)




    def memInitializer(self):

        localctx = CPP14Parser.MemInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_memInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1859
            self.meminitializerid()
            self.state = 1866
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [85]:
                self.state = 1860
                self.match(CPP14Parser.LeftParen)
                self.state = 1862
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474400910417) != 0 or _la==132:
                    self.state = 1861
                    self.expressionList()


                self.state = 1864
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [89]:
                self.state = 1865
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MeminitializeridContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrDeclType(self):
            return self.getTypedRuleContext(CPP14Parser.ClassOrDeclTypeContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_meminitializerid

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMeminitializerid" ):
                listener.enterMeminitializerid(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMeminitializerid" ):
                listener.exitMeminitializerid(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMeminitializerid" ):
                return visitor.visitMeminitializerid(self)
            else:
                return visitor.visitChildren(self)




    def meminitializerid(self):

        localctx = CPP14Parser.MeminitializeridContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_meminitializerid)
        try:
            self.state = 1870
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1868
                self.classOrDeclType()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1869
                self.match(CPP14Parser.Identifier)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperatorFunctionIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def theOperator(self):
            return self.getTypedRuleContext(CPP14Parser.TheOperatorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_operatorFunctionId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOperatorFunctionId" ):
                listener.enterOperatorFunctionId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOperatorFunctionId" ):
                listener.exitOperatorFunctionId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperatorFunctionId" ):
                return visitor.visitOperatorFunctionId(self)
            else:
                return visitor.visitChildren(self)




    def operatorFunctionId(self):

        localctx = CPP14Parser.OperatorFunctionIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_operatorFunctionId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1872
            self.match(CPP14Parser.Operator)
            self.state = 1873
            self.theOperator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralOperatorIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def UserDefinedStringLiteral(self):
            return self.getToken(CPP14Parser.UserDefinedStringLiteral, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_literalOperatorId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteralOperatorId" ):
                listener.enterLiteralOperatorId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteralOperatorId" ):
                listener.exitLiteralOperatorId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteralOperatorId" ):
                return visitor.visitLiteralOperatorId(self)
            else:
                return visitor.visitChildren(self)




    def literalOperatorId(self):

        localctx = CPP14Parser.LiteralOperatorIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_literalOperatorId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1875
            self.match(CPP14Parser.Operator)
            self.state = 1879
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.state = 1876
                self.match(CPP14Parser.StringLiteral)
                self.state = 1877
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [140]:
                self.state = 1878
                self.match(CPP14Parser.UserDefinedStringLiteral)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def templateparameterList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateparameterListContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateDeclaration" ):
                listener.enterTemplateDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateDeclaration" ):
                listener.exitTemplateDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateDeclaration" ):
                return visitor.visitTemplateDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def templateDeclaration(self):

        localctx = CPP14Parser.TemplateDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_templateDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1881
            self.match(CPP14Parser.Template)
            self.state = 1882
            self.match(CPP14Parser.Less)
            self.state = 1883
            self.templateparameterList()
            self.state = 1884
            self.match(CPP14Parser.Greater)
            self.state = 1885
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateparameterListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TemplateParameterContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TemplateParameterContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateparameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateparameterList" ):
                listener.enterTemplateparameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateparameterList" ):
                listener.exitTemplateparameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateparameterList" ):
                return visitor.visitTemplateparameterList(self)
            else:
                return visitor.visitChildren(self)




    def templateparameterList(self):

        localctx = CPP14Parser.TemplateparameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_templateparameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1887
            self.templateParameter()
            self.state = 1892
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1888
                self.match(CPP14Parser.Comma)
                self.state = 1889
                self.templateParameter()
                self.state = 1894
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeParameter(self):
            return self.getTypedRuleContext(CPP14Parser.TypeParameterContext,0)


        def parameterDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateParameter" ):
                listener.enterTemplateParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateParameter" ):
                listener.exitTemplateParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateParameter" ):
                return visitor.visitTemplateParameter(self)
            else:
                return visitor.visitChildren(self)




    def templateParameter(self):

        localctx = CPP14Parser.TemplateParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_templateParameter)
        try:
            self.state = 1897
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1895
                self.typeParameter()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1896
                self.parameterDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def templateparameterList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateparameterListContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeParameter" ):
                listener.enterTypeParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeParameter" ):
                listener.exitTypeParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeParameter" ):
                return visitor.visitTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def typeParameter(self):

        localctx = CPP14Parser.TypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_typeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1908
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [21, 68]:
                self.state = 1904
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1899
                    self.match(CPP14Parser.Template)
                    self.state = 1900
                    self.match(CPP14Parser.Less)
                    self.state = 1901
                    self.templateparameterList()
                    self.state = 1902
                    self.match(CPP14Parser.Greater)


                self.state = 1906
                self.match(CPP14Parser.Class)
                pass
            elif token in [76]:
                self.state = 1907
                self.match(CPP14Parser.Typename_)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1921
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
            if la_ == 1:
                self.state = 1911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1910
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1914
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==132:
                    self.state = 1913
                    self.match(CPP14Parser.Identifier)


                pass

            elif la_ == 2:
                self.state = 1917
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==132:
                    self.state = 1916
                    self.match(CPP14Parser.Identifier)


                self.state = 1919
                self.match(CPP14Parser.Assign)
                self.state = 1920
                self.theTypeId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTemplateIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateName(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateNameContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def templateArgumentList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateArgumentListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTemplateId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTemplateId" ):
                listener.enterSimpleTemplateId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTemplateId" ):
                listener.exitSimpleTemplateId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTemplateId" ):
                return visitor.visitSimpleTemplateId(self)
            else:
                return visitor.visitChildren(self)




    def simpleTemplateId(self):

        localctx = CPP14Parser.SimpleTemplateIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_simpleTemplateId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1923
            self.templateName()
            self.state = 1924
            self.match(CPP14Parser.Less)
            self.state = 1926
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979472930990334) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384268307) != 0 or _la==132:
                self.state = 1925
                self.templateArgumentList()


            self.state = 1928
            self.match(CPP14Parser.Greater)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def operatorFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.OperatorFunctionIdContext,0)


        def literalOperatorId(self):
            return self.getTypedRuleContext(CPP14Parser.LiteralOperatorIdContext,0)


        def templateArgumentList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateArgumentListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateId" ):
                listener.enterTemplateId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateId" ):
                listener.exitTemplateId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateId" ):
                return visitor.visitTemplateId(self)
            else:
                return visitor.visitChildren(self)




    def templateId(self):

        localctx = CPP14Parser.TemplateIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_templateId)
        self._la = 0 # Token type
        try:
            self.state = 1941
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1930
                self.simpleTemplateId()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1933
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,281,self._ctx)
                if la_ == 1:
                    self.state = 1931
                    self.operatorFunctionId()
                    pass

                elif la_ == 2:
                    self.state = 1932
                    self.literalOperatorId()
                    pass


                self.state = 1935
                self.match(CPP14Parser.Less)
                self.state = 1937
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979472930990334) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384268307) != 0 or _la==132:
                    self.state = 1936
                    self.templateArgumentList()


                self.state = 1939
                self.match(CPP14Parser.Greater)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateName" ):
                listener.enterTemplateName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateName" ):
                listener.exitTemplateName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateName" ):
                return visitor.visitTemplateName(self)
            else:
                return visitor.visitChildren(self)




    def templateName(self):

        localctx = CPP14Parser.TemplateNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_templateName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1943
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateArgumentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TemplateArgumentContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TemplateArgumentContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateArgumentList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateArgumentList" ):
                listener.enterTemplateArgumentList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateArgumentList" ):
                listener.exitTemplateArgumentList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateArgumentList" ):
                return visitor.visitTemplateArgumentList(self)
            else:
                return visitor.visitChildren(self)




    def templateArgumentList(self):

        localctx = CPP14Parser.TemplateArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_templateArgumentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1945
            self.templateArgument()
            self.state = 1947
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1946
                self.match(CPP14Parser.Ellipsis)


            self.state = 1956
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 1949
                self.match(CPP14Parser.Comma)
                self.state = 1950
                self.templateArgument()
                self.state = 1952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1951
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1958
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateArgument" ):
                listener.enterTemplateArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateArgument" ):
                listener.exitTemplateArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateArgument" ):
                return visitor.visitTemplateArgument(self)
            else:
                return visitor.visitChildren(self)




    def templateArgument(self):

        localctx = CPP14Parser.TemplateArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_templateArgument)
        try:
            self.state = 1962
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1959
                self.theTypeId()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1960
                self.constantExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1961
                self.idExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeNameSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeNameSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeNameSpecifier" ):
                listener.enterTypeNameSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeNameSpecifier" ):
                listener.exitTypeNameSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeNameSpecifier" ):
                return visitor.visitTypeNameSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def typeNameSpecifier(self):

        localctx = CPP14Parser.TypeNameSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_typeNameSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1964
            self.match(CPP14Parser.Typename_)
            self.state = 1965
            self.nestedNameSpecifier(0)
            self.state = 1971
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 1966
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.state = 1968
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1967
                    self.match(CPP14Parser.Template)


                self.state = 1970
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplicitInstantiationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_explicitInstantiation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitInstantiation" ):
                listener.enterExplicitInstantiation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitInstantiation" ):
                listener.exitExplicitInstantiation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplicitInstantiation" ):
                return visitor.visitExplicitInstantiation(self)
            else:
                return visitor.visitChildren(self)




    def explicitInstantiation(self):

        localctx = CPP14Parser.ExplicitInstantiationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_explicitInstantiation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1974
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==36:
                self.state = 1973
                self.match(CPP14Parser.Extern)


            self.state = 1976
            self.match(CPP14Parser.Template)
            self.state = 1977
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplicitSpecializationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_explicitSpecialization

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitSpecialization" ):
                listener.enterExplicitSpecialization(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitSpecialization" ):
                listener.exitExplicitSpecialization(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplicitSpecialization" ):
                return visitor.visitExplicitSpecialization(self)
            else:
                return visitor.visitChildren(self)




    def explicitSpecialization(self):

        localctx = CPP14Parser.ExplicitSpecializationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_explicitSpecialization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1979
            self.match(CPP14Parser.Template)
            self.state = 1980
            self.match(CPP14Parser.Less)
            self.state = 1981
            self.match(CPP14Parser.Greater)
            self.state = 1982
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TryBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Try(self):
            return self.getToken(CPP14Parser.Try, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def handlerSeq(self):
            return self.getTypedRuleContext(CPP14Parser.HandlerSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_tryBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTryBlock" ):
                listener.enterTryBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTryBlock" ):
                listener.exitTryBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTryBlock" ):
                return visitor.visitTryBlock(self)
            else:
                return visitor.visitChildren(self)




    def tryBlock(self):

        localctx = CPP14Parser.TryBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_tryBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1984
            self.match(CPP14Parser.Try)
            self.state = 1985
            self.compoundStatement()
            self.state = 1986
            self.handlerSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTryBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Try(self):
            return self.getToken(CPP14Parser.Try, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def handlerSeq(self):
            return self.getTypedRuleContext(CPP14Parser.HandlerSeqContext,0)


        def constructorInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ConstructorInitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_functionTryBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTryBlock" ):
                listener.enterFunctionTryBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTryBlock" ):
                listener.exitFunctionTryBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTryBlock" ):
                return visitor.visitFunctionTryBlock(self)
            else:
                return visitor.visitChildren(self)




    def functionTryBlock(self):

        localctx = CPP14Parser.FunctionTryBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_functionTryBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1988
            self.match(CPP14Parser.Try)
            self.state = 1990
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==126:
                self.state = 1989
                self.constructorInitializer()


            self.state = 1992
            self.compoundStatement()
            self.state = 1993
            self.handlerSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HandlerSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def handler(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.HandlerContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.HandlerContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_handlerSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHandlerSeq" ):
                listener.enterHandlerSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHandlerSeq" ):
                listener.exitHandlerSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHandlerSeq" ):
                return visitor.visitHandlerSeq(self)
            else:
                return visitor.visitChildren(self)




    def handlerSeq(self):

        localctx = CPP14Parser.HandlerSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_handlerSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1996 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1995
                self.handler()
                self.state = 1998 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==17):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HandlerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Catch(self):
            return self.getToken(CPP14Parser.Catch, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def exceptionDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionDeclarationContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_handler

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHandler" ):
                listener.enterHandler(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHandler" ):
                listener.exitHandler(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHandler" ):
                return visitor.visitHandler(self)
            else:
                return visitor.visitChildren(self)




    def handler(self):

        localctx = CPP14Parser.HandlerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_handler)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2000
            self.match(CPP14Parser.Catch)
            self.state = 2001
            self.match(CPP14Parser.LeftParen)
            self.state = 2002
            self.exceptionDeclaration()
            self.state = 2003
            self.match(CPP14Parser.RightParen)
            self.state = 2004
            self.compoundStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExceptionDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_exceptionDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExceptionDeclaration" ):
                listener.enterExceptionDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExceptionDeclaration" ):
                listener.exitExceptionDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExceptionDeclaration" ):
                return visitor.visitExceptionDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def exceptionDeclaration(self):

        localctx = CPP14Parser.ExceptionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_exceptionDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 2015
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10, 13, 14, 18, 19, 20, 21, 22, 26, 30, 33, 39, 45, 46, 60, 61, 66, 76, 77, 78, 81, 82, 83, 87, 127, 132]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2007
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10 or _la==87:
                    self.state = 2006
                    self.attributeSpecifierSeq()


                self.state = 2009
                self.typeSpecifierSeq()
                self.state = 2012
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
                if la_ == 1:
                    self.state = 2010
                    self.declarator()

                elif la_ == 2:
                    self.state = 2011
                    self.abstractDeclarator()


                pass
            elif token in [131]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2014
                self.match(CPP14Parser.Ellipsis)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Throw(self):
            return self.getToken(CPP14Parser.Throw, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_throwExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterThrowExpression" ):
                listener.enterThrowExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitThrowExpression" ):
                listener.exitThrowExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrowExpression" ):
                return visitor.visitThrowExpression(self)
            else:
                return visitor.visitChildren(self)




    def throwExpression(self):

        localctx = CPP14Parser.ThrowExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_throwExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2017
            self.match(CPP14Parser.Throw)
            self.state = 2019
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & 8364979464334764286) != 0 or (((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4719772474384133201) != 0 or _la==132:
                self.state = 2018
                self.assignmentExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExceptionSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dynamicExceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.DynamicExceptionSpecificationContext,0)


        def noeExceptSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.NoeExceptSpecificationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_exceptionSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExceptionSpecification" ):
                listener.enterExceptionSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExceptionSpecification" ):
                listener.exitExceptionSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExceptionSpecification" ):
                return visitor.visitExceptionSpecification(self)
            else:
                return visitor.visitChildren(self)




    def exceptionSpecification(self):

        localctx = CPP14Parser.ExceptionSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_exceptionSpecification)
        try:
            self.state = 2023
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [71]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2021
                self.dynamicExceptionSpecification()
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2022
                self.noeExceptSpecification()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DynamicExceptionSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Throw(self):
            return self.getToken(CPP14Parser.Throw, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def typeIdList(self):
            return self.getTypedRuleContext(CPP14Parser.TypeIdListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_dynamicExceptionSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDynamicExceptionSpecification" ):
                listener.enterDynamicExceptionSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDynamicExceptionSpecification" ):
                listener.exitDynamicExceptionSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDynamicExceptionSpecification" ):
                return visitor.visitDynamicExceptionSpecification(self)
            else:
                return visitor.visitChildren(self)




    def dynamicExceptionSpecification(self):

        localctx = CPP14Parser.DynamicExceptionSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_dynamicExceptionSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2025
            self.match(CPP14Parser.Throw)
            self.state = 2026
            self.match(CPP14Parser.LeftParen)
            self.state = 2028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 13)) & ~0x3f) == 0 and ((1 << (_la - 13)) & -9213942612181769245) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 37154696925806707) != 0:
                self.state = 2027
                self.typeIdList()


            self.state = 2030
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeIdListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeId(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TheTypeIdContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeIdList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeIdList" ):
                listener.enterTypeIdList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeIdList" ):
                listener.exitTypeIdList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeIdList" ):
                return visitor.visitTypeIdList(self)
            else:
                return visitor.visitChildren(self)




    def typeIdList(self):

        localctx = CPP14Parser.TypeIdListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_typeIdList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2032
            self.theTypeId()
            self.state = 2034
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 2033
                self.match(CPP14Parser.Ellipsis)


            self.state = 2043
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 2036
                self.match(CPP14Parser.Comma)
                self.state = 2037
                self.theTypeId()
                self.state = 2039
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 2038
                    self.match(CPP14Parser.Ellipsis)


                self.state = 2045
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoeExceptSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Noexcept(self):
            return self.getToken(CPP14Parser.Noexcept, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_noeExceptSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoeExceptSpecification" ):
                listener.enterNoeExceptSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoeExceptSpecification" ):
                listener.exitNoeExceptSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoeExceptSpecification" ):
                return visitor.visitNoeExceptSpecification(self)
            else:
                return visitor.visitChildren(self)




    def noeExceptSpecification(self):

        localctx = CPP14Parser.NoeExceptSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_noeExceptSpecification)
        try:
            self.state = 2052
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,302,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2046
                self.match(CPP14Parser.Noexcept)
                self.state = 2047
                self.match(CPP14Parser.LeftParen)
                self.state = 2048
                self.constantExpression()
                self.state = 2049
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2051
                self.match(CPP14Parser.Noexcept)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def New(self):
            return self.getToken(CPP14Parser.New, 0)

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def Plus(self):
            return self.getToken(CPP14Parser.Plus, 0)

        def Minus(self):
            return self.getToken(CPP14Parser.Minus, 0)

        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def Div(self):
            return self.getToken(CPP14Parser.Div, 0)

        def Mod(self):
            return self.getToken(CPP14Parser.Mod, 0)

        def Caret(self):
            return self.getToken(CPP14Parser.Caret, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Or(self):
            return self.getToken(CPP14Parser.Or, 0)

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def Not(self):
            return self.getToken(CPP14Parser.Not, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def GreaterEqual(self):
            return self.getToken(CPP14Parser.GreaterEqual, 0)

        def PlusAssign(self):
            return self.getToken(CPP14Parser.PlusAssign, 0)

        def MinusAssign(self):
            return self.getToken(CPP14Parser.MinusAssign, 0)

        def StarAssign(self):
            return self.getToken(CPP14Parser.StarAssign, 0)

        def ModAssign(self):
            return self.getToken(CPP14Parser.ModAssign, 0)

        def XorAssign(self):
            return self.getToken(CPP14Parser.XorAssign, 0)

        def AndAssign(self):
            return self.getToken(CPP14Parser.AndAssign, 0)

        def OrAssign(self):
            return self.getToken(CPP14Parser.OrAssign, 0)

        def RightShiftAssign(self):
            return self.getToken(CPP14Parser.RightShiftAssign, 0)

        def LeftShiftAssign(self):
            return self.getToken(CPP14Parser.LeftShiftAssign, 0)

        def Equal(self):
            return self.getToken(CPP14Parser.Equal, 0)

        def NotEqual(self):
            return self.getToken(CPP14Parser.NotEqual, 0)

        def LessEqual(self):
            return self.getToken(CPP14Parser.LessEqual, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def OrOr(self):
            return self.getToken(CPP14Parser.OrOr, 0)

        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def ArrowStar(self):
            return self.getToken(CPP14Parser.ArrowStar, 0)

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_theOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheOperator" ):
                listener.enterTheOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheOperator" ):
                listener.exitTheOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheOperator" ):
                return visitor.visitTheOperator(self)
            else:
                return visitor.visitChildren(self)




    def theOperator(self):

        localctx = CPP14Parser.TheOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_theOperator)
        try:
            self.state = 2105
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,305,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2054
                self.match(CPP14Parser.New)
                self.state = 2057
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,303,self._ctx)
                if la_ == 1:
                    self.state = 2055
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 2056
                    self.match(CPP14Parser.RightBracket)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2059
                self.match(CPP14Parser.Delete)
                self.state = 2062
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
                if la_ == 1:
                    self.state = 2060
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 2061
                    self.match(CPP14Parser.RightBracket)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2064
                self.match(CPP14Parser.Plus)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2065
                self.match(CPP14Parser.Minus)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2066
                self.match(CPP14Parser.Star)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2067
                self.match(CPP14Parser.Div)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2068
                self.match(CPP14Parser.Mod)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2069
                self.match(CPP14Parser.Caret)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2070
                self.match(CPP14Parser.And)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2071
                self.match(CPP14Parser.Or)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2072
                self.match(CPP14Parser.Tilde)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2073
                self.match(CPP14Parser.Not)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2074
                self.match(CPP14Parser.Assign)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2075
                self.match(CPP14Parser.Greater)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 2076
                self.match(CPP14Parser.Less)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 2077
                self.match(CPP14Parser.GreaterEqual)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 2078
                self.match(CPP14Parser.PlusAssign)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 2079
                self.match(CPP14Parser.MinusAssign)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 2080
                self.match(CPP14Parser.StarAssign)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 2081
                self.match(CPP14Parser.ModAssign)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 2082
                self.match(CPP14Parser.XorAssign)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 2083
                self.match(CPP14Parser.AndAssign)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 2084
                self.match(CPP14Parser.OrAssign)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 2085
                self.match(CPP14Parser.Less)
                self.state = 2086
                self.match(CPP14Parser.Less)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 2087
                self.match(CPP14Parser.Greater)
                self.state = 2088
                self.match(CPP14Parser.Greater)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 2089
                self.match(CPP14Parser.RightShiftAssign)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 2090
                self.match(CPP14Parser.LeftShiftAssign)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 2091
                self.match(CPP14Parser.Equal)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 2092
                self.match(CPP14Parser.NotEqual)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 2093
                self.match(CPP14Parser.LessEqual)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 2094
                self.match(CPP14Parser.AndAnd)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 2095
                self.match(CPP14Parser.OrOr)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 2096
                self.match(CPP14Parser.PlusPlus)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 2097
                self.match(CPP14Parser.MinusMinus)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 2098
                self.match(CPP14Parser.Comma)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 2099
                self.match(CPP14Parser.ArrowStar)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 2100
                self.match(CPP14Parser.Arrow)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 2101
                self.match(CPP14Parser.LeftParen)
                self.state = 2102
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 2103
                self.match(CPP14Parser.LeftBracket)
                self.state = 2104
                self.match(CPP14Parser.RightBracket)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IntegerLiteral(self):
            return self.getToken(CPP14Parser.IntegerLiteral, 0)

        def CharacterLiteral(self):
            return self.getToken(CPP14Parser.CharacterLiteral, 0)

        def FloatingLiteral(self):
            return self.getToken(CPP14Parser.FloatingLiteral, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def BooleanLiteral(self):
            return self.getToken(CPP14Parser.BooleanLiteral, 0)

        def PointerLiteral(self):
            return self.getToken(CPP14Parser.PointerLiteral, 0)

        def UserDefinedLiteral(self):
            return self.getToken(CPP14Parser.UserDefinedLiteral, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral" ):
                listener.enterLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral" ):
                listener.exitLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral" ):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)




    def literal(self):

        localctx = CPP14Parser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2107
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 254) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[5] = self.nestedNameSpecifier_sempred
        self._predicates[15] = self.postfixExpression_sempred
        self._predicates[25] = self.noPointerNewDeclarator_sempred
        self._predicates[115] = self.noPointerDeclarator_sempred
        self._predicates[126] = self.noPointerAbstractDeclarator_sempred
        self._predicates[128] = self.noPointerAbstractPackDeclarator_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def nestedNameSpecifier_sempred(self, localctx:NestedNameSpecifierContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def postfixExpression_sempred(self, localctx:PostfixExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 3)
         

    def noPointerNewDeclarator_sempred(self, localctx:NoPointerNewDeclaratorContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         

    def noPointerDeclarator_sempred(self, localctx:NoPointerDeclaratorContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

    def noPointerAbstractDeclarator_sempred(self, localctx:NoPointerAbstractDeclaratorContext, predIndex:int):
            if predIndex == 7:
                return self.precpred(self._ctx, 4)
         

    def noPointerAbstractPackDeclarator_sempred(self, localctx:NoPointerAbstractPackDeclaratorContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         




